Merge branch 'MDL-61819-master' of git://github.com/andrewnicols/moodle
authorDavid Monllao <davidm@moodle.com>
Mon, 16 Apr 2018 14:12:59 +0000 (16:12 +0200)
committerDavid Monllao <davidm@moodle.com>
Mon, 16 Apr 2018 14:12:59 +0000 (16:12 +0200)
74 files changed:
.eslintignore
.stylelintignore
admin/cli/upgrade.php
admin/tool/monitor/classes/privacy/provider.php [new file with mode: 0644]
admin/tool/monitor/classes/rule.php
admin/tool/monitor/lang/en/tool_monitor.php
admin/tool/monitor/tests/privacy_test.php [new file with mode: 0644]
enrol/paypal/ipn.php
grade/export/ods/classes/privacy/provider.php [new file with mode: 0644]
grade/export/ods/lang/en/gradeexport_ods.php
grade/export/txt/classes/privacy/provider.php [new file with mode: 0644]
grade/export/txt/lang/en/gradeexport_txt.php
grade/export/xls/classes/privacy/provider.php [new file with mode: 0644]
grade/export/xls/lang/en/gradeexport_xls.php
grade/export/xml/classes/privacy/provider.php [new file with mode: 0644]
grade/export/xml/lang/en/gradeexport_xml.php
grade/import/csv/classes/privacy/provider.php [new file with mode: 0644]
grade/import/csv/lang/en/gradeimport_csv.php
grade/import/direct/classes/privacy/provider.php [new file with mode: 0644]
grade/import/direct/lang/en/gradeimport_direct.php
grade/import/xml/classes/privacy/provider.php [new file with mode: 0644]
grade/import/xml/lang/en/gradeimport_xml.php
lang/en/admin.php
lib/amd/build/adapter.min.js [new file with mode: 0644]
lib/amd/src/adapter.js [new file with mode: 0644]
lib/classes/plugin_manager.php
lib/editor/atto/db/upgrade.php
lib/editor/atto/plugins/recordrtc/classes/privacy/provider.php [new file with mode: 0644]
lib/editor/atto/plugins/recordrtc/lang/en/atto_recordrtc.php [new file with mode: 0755]
lib/editor/atto/plugins/recordrtc/lib.php [new file with mode: 0644]
lib/editor/atto/plugins/recordrtc/pix/i/audiortc.png [new file with mode: 0644]
lib/editor/atto/plugins/recordrtc/pix/i/videortc.png [new file with mode: 0644]
lib/editor/atto/plugins/recordrtc/pix/icon.png [new file with mode: 0644]
lib/editor/atto/plugins/recordrtc/settings.php [new file with mode: 0644]
lib/editor/atto/plugins/recordrtc/styles.css [new file with mode: 0644]
lib/editor/atto/plugins/recordrtc/version.php [new file with mode: 0644]
lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-button/moodle-atto_recordrtc-button-debug.js [new file with mode: 0644]
lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-button/moodle-atto_recordrtc-button-min.js [new file with mode: 0644]
lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-button/moodle-atto_recordrtc-button.js [new file with mode: 0644]
lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-recording/moodle-atto_recordrtc-recording-debug.js [new file with mode: 0644]
lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-recording/moodle-atto_recordrtc-recording-min.js [new file with mode: 0644]
lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-recording/moodle-atto_recordrtc-recording.js [new file with mode: 0644]
lib/editor/atto/plugins/recordrtc/yui/src/button/build.json [new file with mode: 0755]
lib/editor/atto/plugins/recordrtc/yui/src/button/js/button.js [new file with mode: 0755]
lib/editor/atto/plugins/recordrtc/yui/src/button/meta/button.json [new file with mode: 0644]
lib/editor/atto/plugins/recordrtc/yui/src/recording/build.json [new file with mode: 0644]
lib/editor/atto/plugins/recordrtc/yui/src/recording/js/abstractmodule.js [new file with mode: 0644]
lib/editor/atto/plugins/recordrtc/yui/src/recording/js/audiomodule.js [new file with mode: 0644]
lib/editor/atto/plugins/recordrtc/yui/src/recording/js/commonmodule.js [new file with mode: 0644]
lib/editor/atto/plugins/recordrtc/yui/src/recording/js/compatcheckmodule.js [new file with mode: 0644]
lib/editor/atto/plugins/recordrtc/yui/src/recording/js/videomodule.js [new file with mode: 0644]
lib/editor/atto/plugins/recordrtc/yui/src/recording/meta/recording.json [new file with mode: 0644]
lib/editor/atto/settings.php
lib/editor/atto/version.php
lib/tablelib.php
lib/thirdpartylibs.xml
media/player/html5audio/classes/privacy/provider.php [new file with mode: 0644]
media/player/html5audio/lang/en/media_html5audio.php
media/player/html5video/classes/privacy/provider.php [new file with mode: 0644]
media/player/html5video/lang/en/media_html5video.php
media/player/swf/classes/privacy/provider.php [new file with mode: 0644]
media/player/swf/lang/en/media_swf.php
media/player/videojs/classes/privacy/provider.php [new file with mode: 0644]
media/player/videojs/lang/en/media_videojs.php
media/player/vimeo/classes/privacy/provider.php [new file with mode: 0644]
media/player/vimeo/lang/en/media_vimeo.php
media/player/youtube/classes/privacy/provider.php [new file with mode: 0644]
media/player/youtube/lang/en/media_youtube.php
mod/lti/locallib.php
privacy/classes/tests/request/content_writer.php
privacy/tests/tests_content_writer_test.php
search/classes/output/form/search.php
search/index.php
search/tests/behat/search_query.feature

index 4cbb8e3..84e8dc0 100644 (file)
@@ -56,6 +56,7 @@ lib/maxmind/MaxMind/
 lib/ltiprovider/
 lib/amd/src/truncate.js
 lib/fonts/
+lib/amd/src/adapter.js
 lib/validateurlsyntax.php
 lib/amd/src/popper.js
 media/player/videojs/amd/src/video-lazy.js
index 140b4aa..83f1e76 100644 (file)
@@ -57,6 +57,7 @@ lib/maxmind/MaxMind/
 lib/ltiprovider/
 lib/amd/src/truncate.js
 lib/fonts/
+lib/amd/src/adapter.js
 lib/validateurlsyntax.php
 lib/amd/src/popper.js
 media/player/videojs/amd/src/video-lazy.js
index 6c10b9a..5915e24 100644 (file)
@@ -131,10 +131,11 @@ if (!core_plugin_manager::instance()->all_plugins_ok($version, $failed)) {
     cli_error(get_string('pluginschecktodo', 'admin'));
 }
 
+$a = new stdClass();
+$a->oldversion = $oldversion;
+$a->newversion = $newversion;
+
 if ($interactive) {
-    $a = new stdClass();
-    $a->oldversion = $oldversion;
-    $a->newversion = $newversion;
     echo cli_heading(get_string('databasechecking', '', $a)) . PHP_EOL;
 }
 
@@ -193,5 +194,5 @@ admin_apply_default_settings(NULL, false);
 // to immediately start browsing the site.
 upgrade_themes();
 
-echo get_string('cliupgradefinished', 'admin')."\n";
+echo get_string('cliupgradefinished', 'admin', $a)."\n";
 exit(0); // 0 means success
diff --git a/admin/tool/monitor/classes/privacy/provider.php b/admin/tool/monitor/classes/privacy/provider.php
new file mode 100644 (file)
index 0000000..9b481d3
--- /dev/null
@@ -0,0 +1,211 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle 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, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle 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 Moodle.  If not, see <http://www.gnu.org/licenses/>.
+/**
+ * Privacy class for requesting user data.
+ *
+ * @package    tool_monitor
+ * @copyright  2018 Adrian Greeve <adrian@moodle.com>
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+namespace tool_monitor\privacy;
+
+defined('MOODLE_INTERNAL') || die();
+
+use \core_privacy\local\metadata\collection;
+use \core_privacy\local\request\contextlist;
+use \core_privacy\local\request\approved_contextlist;
+use \core_privacy\local\request\transform;
+use \core_privacy\local\request\writer;
+use \tool_monitor\subscription_manager;
+use \tool_monitor\rule_manager;
+
+/**
+ * Privacy provider for tool_monitor
+ *
+ * @package    tool_monitor
+ * @copyright  2018 Adrian Greeve <adrian@moodle.com>
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class provider implements \core_privacy\local\metadata\provider, \core_privacy\local\request\plugin\provider {
+
+    /**
+     * Get information about the user data stored by this plugin.
+     *
+     * @param  collection $collection An object for storing metadata.
+     * @return collection The metadata.
+     */
+    public static function get_metadata(collection $collection) : collection {
+        $toolmonitorrules = [
+            'description' => 'privacy:metadata:description',
+            'name' => 'privacy:metadata:name',
+            'userid' => 'privacy:metadata:userid',
+            'plugin' => 'privacy:metadata:plugin',
+            'eventname' => 'privacy:metadata:eventname',
+            'template' => 'privacy:metadata:template',
+            'frequency' => 'privacy:metadata:frequency',
+            'timewindow' => 'privacy:metadata:timewindow',
+            'timemodified' => 'privacy:metadata:timemodifiedrule',
+            'timecreated' => 'privacy:metadata:timecreatedrule'
+        ];
+        $toolmonitorsubscriptions = [
+            'userid' => 'privacy:metadata:useridsub',
+            'timecreated' => 'privacy:metadata:timecreatedsub',
+            'lastnotificationsent' => 'privacy:metadata:lastnotificationsent',
+            'inactivedate' => 'privacy:metadata:inactivedate'
+        ];
+        // Tool monitor history doesn't look like it is used at all.
+        $toolmonitorhistory = [
+            'userid' => 'privacy:metadata:useridhistory',
+            'timesent' => 'privacy:metadata:timesent'
+        ];
+        $collection->add_database_table('tool_monitor_rules', $toolmonitorrules, 'privacy:metadata:rulessummary');
+        $collection->add_database_table('tool_monitor_subscriptions', $toolmonitorsubscriptions,
+                'privacy:metadata:subscriptionssummary');
+        $collection->add_database_table('tool_monitor_history', $toolmonitorhistory, 'privacy:metadata:historysummary');
+        $collection->link_subsystem('core_message', 'privacy:metadata:messagesummary');
+        return $collection;
+    }
+
+    /**
+     * Return all contexts for this userid. In this situation the user context.
+     *
+     * @param  int $userid The user ID.
+     * @return contextlist The list of context IDs.
+     */
+    public static function get_contexts_for_userid(int $userid) : contextlist {
+        $params = ['useridrules' => $userid, 'useridsubscriptions' => $userid, 'contextuserrule' => CONTEXT_USER,
+                'contextusersub' => CONTEXT_USER];
+        $sql = "SELECT DISTINCT ctx.id
+                  FROM {context} ctx
+             LEFT JOIN {tool_monitor_rules} mr ON ctx.instanceid = mr.userid AND ctx.contextlevel = :contextuserrule
+             LEFT JOIN {tool_monitor_subscriptions} ms ON ctx.instanceid = ms.userid AND ctx.contextlevel = :contextusersub
+                 WHERE (ms.userid = :useridrules OR mr.userid = :useridsubscriptions)";
+
+        $contextlist = new contextlist();
+        $contextlist->add_from_sql($sql, $params);
+        return $contextlist;
+    }
+
+    /**
+     * Export all event monitor information for the list of contexts and this user.
+     *
+     * @param  approved_contextlist $contextlist The list of approved contexts for a user.
+     */
+    public static function export_user_data(approved_contextlist $contextlist) {
+        global $DB;
+        // Export rules.
+        $context = \context_user::instance($contextlist->get_user()->id);
+        $rules = $DB->get_records('tool_monitor_rules', ['userid' => $contextlist->get_user()->id]);
+        if ($rules) {
+            static::export_monitor_rules($rules, $context);
+        }
+        // Export subscriptions.
+        $subscriptions = subscription_manager::get_user_subscriptions(0, 0, $contextlist->get_user()->id);
+        if ($subscriptions) {
+            static::export_monitor_subscriptions($subscriptions, $context);
+        }
+    }
+
+    /**
+     * Delete all user data for this context.
+     *
+     * @param  \context $context The context to delete data for.
+     */
+    public static function delete_data_for_all_users_in_context(\context $context) {
+        // Only delete data for user contexts.
+        if ($context->contextlevel == CONTEXT_USER) {
+            static::delete_user_data($context->instanceid);
+        }
+    }
+
+    /**
+     * Delete all user data for this user only.
+     *
+     * @param  approved_contextlist $contextlist The list of approved contexts for a user.
+     */
+    public static function delete_data_for_user(approved_contextlist $contextlist) {
+        static::delete_user_data($contextlist->get_user()->id);
+    }
+
+    /**
+     * This does the deletion of user data for the event monitor.
+     *
+     * @param  int $userid The user ID
+     */
+    protected static function delete_user_data(int $userid) {
+        global $DB;
+        // Delete this user's subscriptions first.
+        subscription_manager::delete_user_subscriptions($userid);
+        // Because we only use user contexts the instance ID is the user ID.
+        // Get the rules and check if this user has the capability to delete them.
+        $rules = $DB->get_records('tool_monitor_rules', ['userid' => $userid]);
+        foreach ($rules as $ruledata) {
+            $rule = rule_manager::get_rule($ruledata);
+            // If no-one is suscribed to the rule then it is safe to delete.
+            if ($rule->can_manage_rule($userid) && subscription_manager::count_rule_subscriptions($rule->id) == 0) {
+                $rule->delete_rule();
+            }
+        }
+    }
+
+    /**
+     * This formats and then exports the monitor rules.
+     *
+     * @param  array $rules The monitor rules.
+     * @param  context_user $context The user context
+     */
+    protected static function export_monitor_rules(array $rules, \context_user $context) {
+        foreach ($rules as $rule) {
+            $rule = rule_manager::get_rule($rule);
+            $ruledata = new \stdClass();
+            $ruledata->name = $rule->name;
+            $ruledata->eventname = $rule->get_event_name();
+            $ruledata->description = $rule->get_description($context);
+            $ruledata->plugin = $rule->get_plugin_name();
+            $ruledata->template = $rule->template;
+            $ruledata->frequency = $rule->get_filters_description();
+            $ruledata->course = $rule->get_course_name($context);
+            $ruledata->timecreated = transform::datetime($rule->timecreated);
+            $ruledata->timemodified = transform::datetime($rule->timemodified);
+            writer::with_context($context)->export_data([get_string('privacy:createdrules', 'tool_monitor'),
+                    $rule->name . '_' . $rule->id], $ruledata);
+        }
+    }
+
+    /**
+     * This formats and then exports the event monitor subscriptions.
+     *
+     * @param  array $subscriptions Subscriptions
+     * @param  \context_user $context The user context
+     */
+    protected static function export_monitor_subscriptions(array $subscriptions, \context_user $context) {
+        foreach ($subscriptions as $subscription) {
+            $subscriptiondata = new \stdClass();
+            $subscriptiondata->instancename = $subscription->get_instance_name();
+            $subscriptiondata->eventname = $subscription->get_event_name();
+            $subscriptiondata->frequency = $subscription->get_filters_description();
+            $subscriptiondata->name = $subscription->get_name($context);
+            $subscriptiondata->description = $subscription->get_description($context);
+            $subscriptiondata->pluginname = $subscription->get_plugin_name();
+            $subscriptiondata->course = $subscription->get_course_name($context);
+            $subscriptiondata->timecreated = transform::datetime($subscription->timecreated);
+            $subscriptiondata->lastnotificationsent = transform::datetime($subscription->lastnotificationsent);
+            writer::with_context($context)->export_data([get_string('privacy:subscriptions', 'tool_monitor'),
+                    $subscriptiondata->name . '_' . $subscription->id, $subscriptiondata->course, $subscriptiondata->instancename],
+                    $subscriptiondata);
+        }
+    }
+}
index 3c5e6d2..4cc3920 100644 (file)
@@ -51,14 +51,15 @@ class rule {
     }
 
     /**
-     * Can the current user manage this rule?
+     * Can the user manage this rule? Defaults to $USER.
      *
+     * @param int $userid Check against this userid.
      * @return bool true if the current user can manage this rule, else false.
      */
-    public function can_manage_rule() {
+    public function can_manage_rule($userid = null) {
         $courseid = $this->courseid;
         $context = empty($courseid) ? \context_system::instance() : \context_course::instance($this->courseid);
-        return has_capability('tool/monitor:managerules', $context);
+        return has_capability('tool/monitor:managerules', $context, $userid);
     }
 
     /**
index ed41095..81d20bb 100644 (file)
@@ -79,6 +79,28 @@ $string['monitor:managetool'] = 'Enable/disable event monitoring';
 $string['monitor:subscribe'] = 'Subscribe to event monitor rules';
 $string['norules'] = 'There are no event monitoring rules.';
 $string['pluginname'] = 'Event monitor';
+$string['privacy:createdrules'] = 'Event monitor rules I created';
+$string['privacy:metadata:description'] = 'Description of the rule';
+$string['privacy:metadata:eventname'] = 'Fully qualified name of the event';
+$string['privacy:metadata:frequency'] = 'Frequency of notifications';
+$string['privacy:metadata:historysummary'] = 'Stores the history of the message notifications sent';
+$string['privacy:metadata:inactivedate'] = 'Period of time, in days, after which an inactive subscription will be removed completely';
+$string['privacy:metadata:lastnotificationsent'] = 'When a notification was last sent for this subscription.';
+$string['privacy:metadata:messagesummary'] = 'Notifications are sent to the message system.';
+$string['privacy:metadata:name'] = 'Name of the rule';
+$string['privacy:metadata:plugin'] = 'Frankenstlye name of the plugin';
+$string['privacy:metadata:rulessummary'] = 'This stores monitor rules.';
+$string['privacy:metadata:subscriptionssummary'] = 'Stores user subscriptions to various rules';
+$string['privacy:metadata:template'] = 'Message template';
+$string['privacy:metadata:timecreatedrule'] = 'When this rule was created';
+$string['privacy:metadata:timecreatedsub'] = 'When this subscription was created';
+$string['privacy:metadata:timemodifiedrule'] = 'When this rule was last modified';
+$string['privacy:metadata:timesent'] = 'When the message was sent';
+$string['privacy:metadata:timewindow'] = 'Time window in seconds';
+$string['privacy:metadata:userid'] = 'Id of user who created the rule';
+$string['privacy:metadata:useridhistory'] = 'User to whom this notification was sent';
+$string['privacy:metadata:useridsub'] = 'User id of the subscriber';
+$string['privacy:subscriptions'] = 'My event monitor subscriptions';
 $string['processevents'] = 'Process events';
 $string['rulename'] = 'Rule name';
 $string['ruleareyousure'] = 'Are you sure you want to delete the rule "{$a}"?';
diff --git a/admin/tool/monitor/tests/privacy_test.php b/admin/tool/monitor/tests/privacy_test.php
new file mode 100644 (file)
index 0000000..5c5f11c
--- /dev/null
@@ -0,0 +1,289 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle 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, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle 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 Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Privacy test for the event monitor
+ *
+ * @package    tool_monitor
+ * @category   test
+ * @copyright  2018 Adrian Greeve <adriangreeve.com>
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+defined('MOODLE_INTERNAL') || die();
+
+use \tool_monitor\privacy\provider;
+use \core_privacy\local\request\approved_contextlist;
+
+/**
+ * Privacy test for the event monitor
+ *
+ * @package    tool_monitor
+ * @category   test
+ * @copyright  2018 Adrian Greeve <adriangreeve.com>
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class tool_monitor_privacy_testcase extends advanced_testcase {
+
+    /**
+     * Set up method.
+     */
+    public function setUp() {
+        $this->resetAfterTest();
+        // Enable monitor.
+        set_config('enablemonitor', 1, 'tool_monitor');
+    }
+
+    /**
+     * Assign a capability to $USER
+     * The function creates a student $USER if $USER->id is empty
+     *
+     * @param string $capability capability name
+     * @param int $contextid
+     * @param int $roleid
+     * @return int the role id - mainly returned for creation, so calling function can reuse it
+     */
+    public static function assign_user_capability($capability, $contextid, $roleid = null) {
+        global $USER;
+
+        // Create a new student $USER if $USER doesn't exist.
+        if (empty($USER->id)) {
+            $user  = self::getDataGenerator()->create_user();
+            self::setUser($user);
+        }
+
+        if (empty($roleid)) {
+            $roleid = create_role('Dummy role', 'dummyrole', 'dummy role description');
+        }
+
+        assign_capability($capability, CAP_ALLOW, $roleid, $contextid);
+
+        role_assign($roleid, $USER->id, $contextid);
+
+        accesslib_clear_all_caches_for_unit_testing();
+
+        return $roleid;
+    }
+
+    /**
+     * Test that a collection with data is returned when calling this function.
+     */
+    public function test_get_metadata() {
+        $collection = new \core_privacy\local\metadata\collection('tool_monitor');
+        $collection = provider::get_metadata($collection);
+        $this->assertNotEmpty($collection);
+    }
+
+    /**
+     * Check that a user context is returned if there is any user data for this user.
+     */
+    public function test_get_contexts_for_userid() {
+        $user = $this->getDataGenerator()->create_user();
+        $user2 = $this->getDataGenerator()->create_user();
+        $usercontext = \context_user::instance($user->id);
+        $usercontext2 = \context_user::instance($user2->id);
+        $this->assertEmpty(provider::get_contexts_for_userid($user->id));
+        $this->assertEmpty(provider::get_contexts_for_userid($user2->id));
+
+        $monitorgenerator = $this->getDataGenerator()->get_plugin_generator('tool_monitor');
+
+        // Create a rule with this user.
+        $this->setUser($user);
+        $rule = $monitorgenerator->create_rule();
+        $contextlist = provider::get_contexts_for_userid($user->id);
+
+        // Check that we only get back one context.
+        $this->assertCount(1, $contextlist);
+
+        // Check that a context is returned for just creating a rule.
+        $this->assertEquals($usercontext->id, $contextlist->get_contextids()[0]);
+
+        $this->setUser($user2);
+
+        $record = new stdClass();
+        $record->courseid = 0;
+        $record->userid = $user2->id;
+        $record->ruleid = $rule->id;
+
+        $subscription = $monitorgenerator->create_subscription($record);
+        $contextlist = provider::get_contexts_for_userid($user2->id);
+
+        // Check that we only get back one context.
+        $this->assertCount(1, $contextlist);
+
+        // Check that a context is returned for just subscribing to a rule.
+        $this->assertEquals($usercontext2->id, $contextlist->get_contextids()[0]);
+    }
+
+    /**
+     * Test that user data is exported correctly.
+     */
+    public function test_export_user_data() {
+        $user = $this->getDataGenerator()->create_user();
+        $usercontext = \context_user::instance($user->id);
+        $monitorgenerator = $this->getDataGenerator()->get_plugin_generator('tool_monitor');
+
+        $this->setUser($user);
+        $rulerecord = (object)['name' => 'privacy rule'];
+        $rule = $monitorgenerator->create_rule($rulerecord);
+
+        $secondrulerecord = (object)['name' => 'privacy rule2'];
+        $rule2 = $monitorgenerator->create_rule($secondrulerecord);
+
+        $subscription = (object)['ruleid' => $rule->id, 'userid' => $user->id];
+        $subscription = $monitorgenerator->create_subscription($subscription);
+
+        $writer = \core_privacy\local\request\writer::with_context($usercontext);
+        $this->assertFalse($writer->has_any_data());
+
+        $approvedlist = new approved_contextlist($user, 'tool_monitor', [$usercontext->id]);
+        provider::export_user_data($approvedlist);
+
+        // Check that the rules created by this user are exported.
+        $this->assertEquals($rulerecord->name, $writer->get_data([get_string('privacy:createdrules', 'tool_monitor'),
+                $rulerecord->name . '_' . $rule->id])->name);
+        $this->assertEquals($secondrulerecord->name, $writer->get_data([get_string('privacy:createdrules', 'tool_monitor'),
+                $secondrulerecord->name . '_' . $rule2->id])->name);
+
+        // Check that the subscriptions for this user are also exported.
+        $this->assertEquals($rulerecord->name, $writer->get_data([get_string('privacy:subscriptions', 'tool_monitor'),
+                $rulerecord->name . '_' . $subscription->id, 'Site' , 'All events'])->name);
+    }
+
+    /**
+     * Test deleting all user data for a specific context.
+     */
+    public function test_delete_data_for_all_users_in_context() {
+        global $DB;
+
+        $user = $this->getDataGenerator()->create_user();
+        $user2 = $this->getDataGenerator()->create_user();
+        $usercontext = \context_user::instance($user->id);
+        $usercontext2 = \context_user::instance($user2->id);
+        $monitorgenerator = $this->getDataGenerator()->get_plugin_generator('tool_monitor');
+
+        $this->setUser($user);
+        // Need to give user one the ability to manage rules.
+        $this->assign_user_capability('tool/monitor:managerules', \context_system::instance());
+
+        $rulerecord = (object)['name' => 'privacy rule'];
+        $rule = $monitorgenerator->create_rule($rulerecord);
+
+        $secondrulerecord = (object)['name' => 'privacy rule2'];
+        $rule2 = $monitorgenerator->create_rule($secondrulerecord);
+
+        $subscription = (object)['ruleid' => $rule->id, 'userid' => $user->id];
+        $subscription = $monitorgenerator->create_subscription($subscription);
+
+        // Have user 2 subscribe to the second rule created by user 1.
+        $subscription2 = (object)['ruleid' => $rule2->id, 'userid' => $user2->id];
+        $subscription2 = $monitorgenerator->create_subscription($subscription2);
+
+        $this->setUser($user2);
+        $thirdrulerecord = (object)['name' => 'privacy rule for second user'];
+        $rule3 = $monitorgenerator->create_rule($thirdrulerecord);
+
+        $subscription3 = (object)['ruleid' => $rule3->id, 'userid' => $user2->id];
+        $subscription3 = $monitorgenerator->create_subscription($subscription3);
+
+        // Try a different context first.
+        provider::delete_data_for_all_users_in_context(context_system::instance());
+
+        // Get all of the monitor rules.
+        $dbrules = $DB->get_records('tool_monitor_rules');
+
+        // All of the rules should still be present.
+        $this->assertCount(3, $dbrules);
+        $this->assertEquals($user->id, $dbrules[$rule->id]->userid);
+        $this->assertEquals($user->id, $dbrules[$rule2->id]->userid);
+        $this->assertEquals($user2->id, $dbrules[$rule3->id]->userid);
+
+        // Delete everything for the first user context.
+        provider::delete_data_for_all_users_in_context($usercontext);
+
+        // Get all of the monitor rules.
+        $dbrules = $DB->get_records('tool_monitor_rules');
+
+        // Only the rules for user 1 that does not have any more subscriptions should be deleted (the first rule).
+        $this->assertCount(2, $dbrules);
+        $this->assertEquals($user->id, $dbrules[$rule2->id]->userid);
+        $this->assertEquals($user2->id, $dbrules[$rule3->id]->userid);
+
+        // Get all of the monitor subscriptions.
+        $dbsubs = $DB->get_records('tool_monitor_subscriptions');
+        // There should be two subscriptions left, both for user 2.
+        $this->assertCount(2, $dbsubs);
+        $this->assertEquals($user2->id, $dbsubs[$subscription2->id]->userid);
+        $this->assertEquals($user2->id, $dbsubs[$subscription3->id]->userid);
+    }
+
+    /**
+     * This should work identical to the above test.
+     */
+    public function test_delete_data_for_user() {
+        global $DB;
+
+        $user = $this->getDataGenerator()->create_user();
+        $user2 = $this->getDataGenerator()->create_user();
+        $usercontext = \context_user::instance($user->id);
+        $usercontext2 = \context_user::instance($user2->id);
+        $monitorgenerator = $this->getDataGenerator()->get_plugin_generator('tool_monitor');
+
+        $this->setUser($user);
+        // Need to give user one the ability to manage rules.
+        $this->assign_user_capability('tool/monitor:managerules', \context_system::instance());
+
+        $rulerecord = (object)['name' => 'privacy rule'];
+        $rule = $monitorgenerator->create_rule($rulerecord);
+
+        $secondrulerecord = (object)['name' => 'privacy rule2'];
+        $rule2 = $monitorgenerator->create_rule($secondrulerecord);
+
+        $subscription = (object)['ruleid' => $rule->id, 'userid' => $user->id];
+        $subscription = $monitorgenerator->create_subscription($subscription);
+
+        // Have user 2 subscribe to the second rule created by user 1.
+        $subscription2 = (object)['ruleid' => $rule2->id, 'userid' => $user2->id];
+        $subscription2 = $monitorgenerator->create_subscription($subscription2);
+
+        $this->setUser($user2);
+        $thirdrulerecord = (object)['name' => 'privacy rule for second user'];
+        $rule3 = $monitorgenerator->create_rule($thirdrulerecord);
+
+        $subscription3 = (object)['ruleid' => $rule3->id, 'userid' => $user2->id];
+        $subscription3 = $monitorgenerator->create_subscription($subscription3);
+
+        $approvedlist = new approved_contextlist($user, 'tool_monitor', [$usercontext->id]);
+
+        // Delete everything for the first user.
+        provider::delete_data_for_user($approvedlist);
+
+        // Get all of the monitor rules.
+        $dbrules = $DB->get_records('tool_monitor_rules');
+
+        // Only the rules for user 1 that does not have any more subscriptions should be deleted (the first rule).
+        $this->assertCount(2, $dbrules);
+        $this->assertEquals($user->id, $dbrules[$rule2->id]->userid);
+        $this->assertEquals($user2->id, $dbrules[$rule3->id]->userid);
+
+        // Get all of the monitor subscriptions.
+        $dbsubs = $DB->get_records('tool_monitor_subscriptions');
+        // There should be two subscriptions left, both for user 2.
+        $this->assertCount(2, $dbsubs);
+        $this->assertEquals($user2->id, $dbsubs[$subscription2->id]->userid);
+        $this->assertEquals($user2->id, $dbsubs[$subscription3->id]->userid);
+    }
+}
index a5b09a5..a686f13 100644 (file)
@@ -103,7 +103,7 @@ $plugin_instance = $DB->get_record("enrol", array("id" => $data->instanceid, "en
 $plugin = enrol_get_plugin('paypal');
 
 /// Open a connection back to PayPal to validate the data
-$paypaladdr = empty($CFG->usepaypalsandbox) ? 'www.paypal.com' : 'www.sandbox.paypal.com';
+$paypaladdr = empty($CFG->usepaypalsandbox) ? 'ipnpb.paypal.com' : 'ipnpb.sandbox.paypal.com';
 $c = new curl();
 $options = array(
     'returntransfer' => true,
@@ -180,19 +180,25 @@ if (strlen($result) > 0) {
 
         // At this point we only proceed with a status of completed or pending with a reason of echeck
 
-
-
-        if ($existing = $DB->get_record("enrol_paypal", array("txn_id"=>$data->txn_id))) {   // Make sure this transaction doesn't exist already
+        // Make sure this transaction doesn't exist already.
+        if ($existing = $DB->get_record("enrol_paypal", array("txn_id" => $data->txn_id), "*", IGNORE_MULTIPLE)) {
             \enrol_paypal\util::message_paypal_error_to_admin("Transaction $data->txn_id is being repeated!", $data);
             die;
+        }
 
+        // Check that the receiver email is the one we want it to be.
+        if (isset($data->business)) {
+            $recipient = $data->business;
+        } else if (isset($data->receiver_email)) {
+            $recipient = $data->receiver_email;
+        } else {
+            $recipient = 'empty';
         }
 
-        if (core_text::strtolower($data->business) !== core_text::strtolower($plugin->get_config('paypalbusiness'))) {   // Check that the email is the one we want it to be
-            \enrol_paypal\util::message_paypal_error_to_admin("Business email is {$data->business} (not ".
+        if (core_text::strtolower($recipient) !== core_text::strtolower($plugin->get_config('paypalbusiness'))) {
+            \enrol_paypal\util::message_paypal_error_to_admin("Business email is {$recipient} (not ".
                     $plugin->get_config('paypalbusiness').")", $data);
             die;
-
         }
 
         if (!$user = $DB->get_record('user', array('id'=>$data->userid))) {   // Check that user exists
diff --git a/grade/export/ods/classes/privacy/provider.php b/grade/export/ods/classes/privacy/provider.php
new file mode 100644 (file)
index 0000000..17688ff
--- /dev/null
@@ -0,0 +1,46 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle 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, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle 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 Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Privacy Subsystem implementation for gradeexport_ods.
+ *
+ * @package    gradeexport_ods
+ * @copyright  2018 Sara Arjona <sara@moodle.com>
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace gradeexport_ods\privacy;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Privacy Subsystem for gradeexport_ods implementing null_provider.
+ *
+ * @copyright  2018 Sara Arjona <sara@moodle.com>
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class provider implements \core_privacy\local\metadata\null_provider {
+
+    /**
+     * Get the language string identifier with the component's language
+     * file to explain why this plugin stores no data.
+     *
+     * @return  string
+     */
+    public static function get_reason() : string {
+        return 'privacy:metadata';
+    }
+}
index 18b7ce3..a8420ae 100644 (file)
@@ -27,4 +27,5 @@ $string['eventgradeexported'] = 'OpenDocument grade exported';
 $string['pluginname'] = 'OpenDocument spreadsheet';
 $string['ods:publish'] = 'Publish ODS grade export';
 $string['ods:view'] = 'Use OpenDocument grade export';
-$string['timeexported'] = 'Last downloaded from this course';
\ No newline at end of file
+$string['privacy:metadata'] = 'The OpenDocument spreadsheet grade export plugin does not store any personal data.';
+$string['timeexported'] = 'Last downloaded from this course';
diff --git a/grade/export/txt/classes/privacy/provider.php b/grade/export/txt/classes/privacy/provider.php
new file mode 100644 (file)
index 0000000..8db03c5
--- /dev/null
@@ -0,0 +1,46 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle 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, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle 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 Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Privacy Subsystem implementation for gradeexport_txt.
+ *
+ * @package    gradeexport_txt
+ * @copyright  2018 Sara Arjona <sara@moodle.com>
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace gradeexport_txt\privacy;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Privacy Subsystem for gradeexport_txt implementing null_provider.
+ *
+ * @copyright  2018 Sara Arjona <sara@moodle.com>
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class provider implements \core_privacy\local\metadata\null_provider {
+
+    /**
+     * Get the language string identifier with the component's language
+     * file to explain why this plugin stores no data.
+     *
+     * @return  string
+     */
+    public static function get_reason() : string {
+        return 'privacy:metadata';
+    }
+}
index fc0f415..df14077 100644 (file)
@@ -25,6 +25,7 @@
 
 $string['eventgradeexported'] = 'TXT grade exported';
 $string['pluginname'] = 'Plain text file';
+$string['privacy:metadata'] = 'The Plain text file grade export plugin does not store any personal data.';
 $string['timeexported'] = 'Last downloaded from this course';
 $string['txt:publish'] = 'Publish TXT grade export';
 $string['txt:view'] = 'Use text grade export';
diff --git a/grade/export/xls/classes/privacy/provider.php b/grade/export/xls/classes/privacy/provider.php
new file mode 100644 (file)
index 0000000..dbb9b96
--- /dev/null
@@ -0,0 +1,46 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle 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, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle 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 Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Privacy Subsystem implementation for gradeexport_xls.
+ *
+ * @package    gradeexport_xls
+ * @copyright  2018 Sara Arjona <sara@moodle.com>
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace gradeexport_xls\privacy;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Privacy Subsystem for gradeexport_xls implementing null_provider.
+ *
+ * @copyright  2018 Sara Arjona <sara@moodle.com>
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class provider implements \core_privacy\local\metadata\null_provider {
+
+    /**
+     * Get the language string identifier with the component's language
+     * file to explain why this plugin stores no data.
+     *
+     * @return  string
+     */
+    public static function get_reason() : string {
+        return 'privacy:metadata';
+    }
+}
index 706fe83..e122e8d 100644 (file)
@@ -25,6 +25,7 @@
 
 $string['eventgradeexported'] = 'XLS grade exported';
 $string['pluginname'] = 'Excel spreadsheet';
+$string['privacy:metadata'] = 'The Excel spreadsheet grade export plugin does not store any personal data.';
 $string['timeexported'] = 'Last downloaded from this course';
 $string['xls:publish'] = 'Publish XLS grade export';
 $string['xls:view'] = 'Use Excel grade export';
diff --git a/grade/export/xml/classes/privacy/provider.php b/grade/export/xml/classes/privacy/provider.php
new file mode 100644 (file)
index 0000000..6c62d39
--- /dev/null
@@ -0,0 +1,46 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle 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, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle 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 Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Privacy Subsystem implementation for gradeexport_xml.
+ *
+ * @package    gradeexport_xml
+ * @copyright  2018 Sara Arjona <sara@moodle.com>
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace gradeexport_xml\privacy;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Privacy Subsystem for gradeexport_xml implementing null_provider.
+ *
+ * @copyright  2018 Sara Arjona <sara@moodle.com>
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class provider implements \core_privacy\local\metadata\null_provider {
+
+    /**
+     * Get the language string identifier with the component's language
+     * file to explain why this plugin stores no data.
+     *
+     * @return  string
+     */
+    public static function get_reason() : string {
+        return 'privacy:metadata';
+    }
+}
index babd5f3..839b965 100644 (file)
@@ -25,5 +25,6 @@
 
 $string['eventgradeexported'] = 'XML grade exported';
 $string['pluginname'] = 'XML file';
+$string['privacy:metadata'] = 'The XML file grade export plugin does not store any personal data.';
 $string['xml:publish'] = 'Publish XML grade export';
 $string['xml:view'] = 'Use XML grade export';
diff --git a/grade/import/csv/classes/privacy/provider.php b/grade/import/csv/classes/privacy/provider.php
new file mode 100644 (file)
index 0000000..8b230fc
--- /dev/null
@@ -0,0 +1,46 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle 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, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle 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 Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Privacy Subsystem implementation for gradeimport_csv.
+ *
+ * @package    gradeimport_csv
+ * @copyright  2018 Sara Arjona <sara@moodle.com>
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace gradeimport_csv\privacy;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Privacy Subsystem for gradeimport_csv implementing null_provider.
+ *
+ * @copyright  2018 Sara Arjona <sara@moodle.com>
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class provider implements \core_privacy\local\metadata\null_provider {
+
+    /**
+     * Get the language string identifier with the component's language
+     * file to explain why this plugin stores no data.
+     *
+     * @return  string
+     */
+    public static function get_reason() : string {
+        return 'privacy:metadata';
+    }
+}
index 18c1784..3e2a209 100644 (file)
@@ -25,3 +25,4 @@
 
 $string['csv:view'] = 'Import grades from CSV';
 $string['pluginname'] = 'CSV file';
+$string['privacy:metadata'] = 'The import grades from CSV plugin does not store any personal data.';
diff --git a/grade/import/direct/classes/privacy/provider.php b/grade/import/direct/classes/privacy/provider.php
new file mode 100644 (file)
index 0000000..8136bec
--- /dev/null
@@ -0,0 +1,46 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle 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, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle 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 Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Privacy Subsystem implementation for gradeimport_direct.
+ *
+ * @package    gradeimport_direct
+ * @copyright  2018 Sara Arjona <sara@moodle.com>
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace gradeimport_direct\privacy;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Privacy Subsystem for gradeimport_direct implementing null_provider.
+ *
+ * @copyright  2018 Sara Arjona <sara@moodle.com>
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class provider implements \core_privacy\local\metadata\null_provider {
+
+    /**
+     * Get the language string identifier with the component's language
+     * file to explain why this plugin stores no data.
+     *
+     * @return  string
+     */
+    public static function get_reason() : string {
+        return 'privacy:metadata';
+    }
+}
index 1218dc0..516c5fc 100644 (file)
@@ -24,6 +24,7 @@
 
 $string['direct:view'] = 'Import grades from CSV';
 $string['pluginname'] = 'Paste from spreadsheet';
+$string['privacy:metadata'] = 'The import grades from copied spreadsheed plugin does not store any personal data.';
 $string['userdata'] = 'Help copying data into this form.';
 $string['userdata_help'] = 'Grades may be copied and pasted from a spreadsheet into the gradebook. The spreadsheet should have a column containing user identity data - either username or ID number or email address. Each column for import should have a column header.';
 $string['userdata_link'] = 'grade/import/direct/index';
diff --git a/grade/import/xml/classes/privacy/provider.php b/grade/import/xml/classes/privacy/provider.php
new file mode 100644 (file)
index 0000000..54f4e46
--- /dev/null
@@ -0,0 +1,46 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle 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, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle 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 Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Privacy Subsystem implementation for gradeimport_xml.
+ *
+ * @package    gradeimport_xml
+ * @copyright  2018 Sara Arjona <sara@moodle.com>
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace gradeimport_xml\privacy;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Privacy Subsystem for gradeimport_xml implementing null_provider.
+ *
+ * @copyright  2018 Sara Arjona <sara@moodle.com>
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class provider implements \core_privacy\local\metadata\null_provider {
+
+    /**
+     * Get the language string identifier with the component's language
+     * file to explain why this plugin stores no data.
+     *
+     * @return  string
+     */
+    public static function get_reason() : string {
+        return 'privacy:metadata';
+    }
+}
index ae6bc29..5000a0a 100644 (file)
@@ -34,6 +34,7 @@ $string['errorduringimport'] = 'An error occurred when trying to import: {$a}';
 $string['fileurl'] = 'Remote file URL';
 $string['fileurl_help'] = 'The remote file URL field is for fetching data from a remote server, such as a student information system.';
 $string['pluginname'] = 'XML file';
+$string['privacy:metadata'] = 'The import grades from XML plugin does not store any personal data.';
 $string['xml:publish'] = 'Publish import grades from XML';
 $string['xml:view'] = 'Import grades from XML';
 $string['importxml'] = 'XML import';
index a2344f0..207dbc2 100644 (file)
@@ -128,7 +128,7 @@ $string['clitypevaluedefault'] = 'type value, press Enter to use default value (
 $string['cliunknowoption'] = 'Unrecognised options:
   {$a}
 Please use --help option.';
-$string['cliupgradefinished'] = 'Command line upgrade completed successfully.';
+$string['cliupgradefinished'] = 'Command line upgrade from {$a->oldversion} to {$a->newversion} completed successfully.';
 $string['cliupgradenoneed'] = 'No upgrade needed for the installed version {$a}. Thanks for coming anyway!';
 $string['cliyesnoprompt'] = 'type y (means yes) or n (means no)';
 $string['commentsperpage'] = 'Comments displayed per page';
diff --git a/lib/amd/build/adapter.min.js b/lib/amd/build/adapter.min.js
new file mode 100644 (file)
index 0000000..08b2c5f
Binary files /dev/null and b/lib/amd/build/adapter.min.js differ
diff --git a/lib/amd/src/adapter.js b/lib/amd/src/adapter.js
new file mode 100644 (file)
index 0000000..282f7b2
--- /dev/null
@@ -0,0 +1,4963 @@
+/**
+ * Description of import/upgrade into Moodle:
+ *
+ * 1. Visit https://github.com/webrtc/adapter/releases.
+ * 2. Check if the version has been updated from what is listed in lib/thirdpartylibs.xml in the Moodle wwwroot.
+ * 3. If it has -
+ *    1. Download the source code.
+ *    2. Copy the content of the file release/adapter.js from the archive (ignore the first line).
+ *    3. Replace the content below "return (function e(t,n,r) .." in this file with the content you copied.
+ *    4. Ensure to update lib/thirdpartylibs.xml with any changes.
+ */
+
+// ESLint directives.
+/* eslint-disable */
+
+// JSHint directives.
+/* jshint ignore:start */
+
+define([], function() {
+return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+/*
+ *  Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree.
+ */
+ /* eslint-env node */
+'use strict';
+
+var SDPUtils = require('sdp');
+
+function writeMediaSection(transceiver, caps, type, stream, dtlsRole) {
+    var sdp = SDPUtils.writeRtpDescription(transceiver.kind, caps);
+
+    // Map ICE parameters (ufrag, pwd) to SDP.
+    sdp += SDPUtils.writeIceParameters(
+        transceiver.iceGatherer.getLocalParameters());
+
+    // Map DTLS parameters to SDP.
+    sdp += SDPUtils.writeDtlsParameters(
+        transceiver.dtlsTransport.getLocalParameters(),
+        type === 'offer' ? 'actpass' : dtlsRole || 'active');
+
+    sdp += 'a=mid:' + transceiver.mid + '\r\n';
+
+    if (transceiver.rtpSender && transceiver.rtpReceiver) {
+        sdp += 'a=sendrecv\r\n';
+    } else if (transceiver.rtpSender) {
+        sdp += 'a=sendonly\r\n';
+    } else if (transceiver.rtpReceiver) {
+        sdp += 'a=recvonly\r\n';
+    } else {
+        sdp += 'a=inactive\r\n';
+    }
+
+    if (transceiver.rtpSender) {
+        var trackId = transceiver.rtpSender._initialTrackId ||
+            transceiver.rtpSender.track.id;
+        transceiver.rtpSender._initialTrackId = trackId;
+        // spec.
+        var msid = 'msid:' + (stream ? stream.id : '-') + ' ' +
+            trackId + '\r\n';
+        sdp += 'a=' + msid;
+        // for Chrome. Legacy should no longer be required.
+        sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].ssrc +
+            ' ' + msid;
+
+        // RTX
+        if (transceiver.sendEncodingParameters[0].rtx) {
+            sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].rtx.ssrc +
+                ' ' + msid;
+            sdp += 'a=ssrc-group:FID ' +
+                transceiver.sendEncodingParameters[0].ssrc + ' ' +
+                transceiver.sendEncodingParameters[0].rtx.ssrc +
+                '\r\n';
+        }
+    }
+    // FIXME: this should be written by writeRtpDescription.
+    sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].ssrc +
+        ' cname:' + SDPUtils.localCName + '\r\n';
+    if (transceiver.rtpSender && transceiver.sendEncodingParameters[0].rtx) {
+        sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].rtx.ssrc +
+            ' cname:' + SDPUtils.localCName + '\r\n';
+    }
+    return sdp;
+}
+
+// Edge does not like
+// 1) stun: filtered after 14393 unless ?transport=udp is present
+// 2) turn: that does not have all of turn:host:port?transport=udp
+// 3) turn: with ipv6 addresses
+// 4) turn: occurring muliple times
+function filterIceServers(iceServers, edgeVersion) {
+    var hasTurn = false;
+    iceServers = JSON.parse(JSON.stringify(iceServers));
+    return iceServers.filter(function(server) {
+        if (server && (server.urls || server.url)) {
+            var urls = server.urls || server.url;
+            if (server.url && !server.urls) {
+                console.warn('RTCIceServer.url is deprecated! Use urls instead.');
+            }
+            var isString = typeof urls === 'string';
+            if (isString) {
+                urls = [urls];
+            }
+            urls = urls.filter(function(url) {
+                var validTurn = url.indexOf('turn:') === 0 &&
+                    url.indexOf('transport=udp') !== -1 &&
+                    url.indexOf('turn:[') === -1 &&
+                    !hasTurn;
+
+                if (validTurn) {
+                    hasTurn = true;
+                    return true;
+                }
+                return url.indexOf('stun:') === 0 && edgeVersion >= 14393 &&
+                    url.indexOf('?transport=udp') === -1;
+            });
+
+            delete server.url;
+            server.urls = isString ? urls[0] : urls;
+            return !!urls.length;
+        }
+    });
+}
+
+// Determines the intersection of local and remote capabilities.
+function getCommonCapabilities(localCapabilities, remoteCapabilities) {
+    var commonCapabilities = {
+        codecs: [],
+        headerExtensions: [],
+        fecMechanisms: []
+    };
+
+    var findCodecByPayloadType = function(pt, codecs) {
+        pt = parseInt(pt, 10);
+        for (var i = 0; i < codecs.length; i++) {
+            if (codecs[i].payloadType === pt ||
+                codecs[i].preferredPayloadType === pt) {
+                return codecs[i];
+            }
+        }
+    };
+
+    var rtxCapabilityMatches = function(lRtx, rRtx, lCodecs, rCodecs) {
+        var lCodec = findCodecByPayloadType(lRtx.parameters.apt, lCodecs);
+        var rCodec = findCodecByPayloadType(rRtx.parameters.apt, rCodecs);
+        return lCodec && rCodec &&
+            lCodec.name.toLowerCase() === rCodec.name.toLowerCase();
+    };
+
+    localCapabilities.codecs.forEach(function(lCodec) {
+        for (var i = 0; i < remoteCapabilities.codecs.length; i++) {
+            var rCodec = remoteCapabilities.codecs[i];
+            if (lCodec.name.toLowerCase() === rCodec.name.toLowerCase() &&
+                lCodec.clockRate === rCodec.clockRate) {
+                if (lCodec.name.toLowerCase() === 'rtx' &&
+                    lCodec.parameters && rCodec.parameters.apt) {
+                    // for RTX we need to find the local rtx that has a apt
+                    // which points to the same local codec as the remote one.
+                    if (!rtxCapabilityMatches(lCodec, rCodec,
+                        localCapabilities.codecs, remoteCapabilities.codecs)) {
+                        continue;
+                    }
+                }
+                rCodec = JSON.parse(JSON.stringify(rCodec)); // deepcopy
+                // number of channels is the highest common number of channels
+                rCodec.numChannels = Math.min(lCodec.numChannels,
+                    rCodec.numChannels);
+                // push rCodec so we reply with offerer payload type
+                commonCapabilities.codecs.push(rCodec);
+
+                // determine common feedback mechanisms
+                rCodec.rtcpFeedback = rCodec.rtcpFeedback.filter(function(fb) {
+                    for (var j = 0; j < lCodec.rtcpFeedback.length; j++) {
+                        if (lCodec.rtcpFeedback[j].type === fb.type &&
+                            lCodec.rtcpFeedback[j].parameter === fb.parameter) {
+                            return true;
+                        }
+                    }
+                    return false;
+                });
+                // FIXME: also need to determine .parameters
+                //  see https://github.com/openpeer/ortc/issues/569
+                break;
+            }
+        }
+    });
+
+    localCapabilities.headerExtensions.forEach(function(lHeaderExtension) {
+        for (var i = 0; i < remoteCapabilities.headerExtensions.length;
+             i++) {
+            var rHeaderExtension = remoteCapabilities.headerExtensions[i];
+            if (lHeaderExtension.uri === rHeaderExtension.uri) {
+                commonCapabilities.headerExtensions.push(rHeaderExtension);
+                break;
+            }
+        }
+    });
+
+    // FIXME: fecMechanisms
+    return commonCapabilities;
+}
+
+// is action=setLocalDescription with type allowed in signalingState
+function isActionAllowedInSignalingState(action, type, signalingState) {
+    return {
+        offer: {
+            setLocalDescription: ['stable', 'have-local-offer'],
+            setRemoteDescription: ['stable', 'have-remote-offer']
+        },
+        answer: {
+            setLocalDescription: ['have-remote-offer', 'have-local-pranswer'],
+            setRemoteDescription: ['have-local-offer', 'have-remote-pranswer']
+        }
+    }[type][action].indexOf(signalingState) !== -1;
+}
+
+function maybeAddCandidate(iceTransport, candidate) {
+    // Edge's internal representation adds some fields therefore
+    // not all fieldÑ• are taken into account.
+    var alreadyAdded = iceTransport.getRemoteCandidates()
+        .find(function(remoteCandidate) {
+            return candidate.foundation === remoteCandidate.foundation &&
+                candidate.ip === remoteCandidate.ip &&
+                candidate.port === remoteCandidate.port &&
+                candidate.priority === remoteCandidate.priority &&
+                candidate.protocol === remoteCandidate.protocol &&
+                candidate.type === remoteCandidate.type;
+        });
+    if (!alreadyAdded) {
+        iceTransport.addRemoteCandidate(candidate);
+    }
+    return !alreadyAdded;
+}
+
+
+function makeError(name, description) {
+    var e = new Error(description);
+    e.name = name;
+    // legacy error codes from https://heycam.github.io/webidl/#idl-DOMException-error-names
+    e.code = {
+        NotSupportedError: 9,
+        InvalidStateError: 11,
+        InvalidAccessError: 15,
+        TypeError: undefined,
+        OperationError: undefined
+    }[name];
+    return e;
+}
+
+module.exports = function(window, edgeVersion) {
+    // https://w3c.github.io/mediacapture-main/#mediastream
+    // Helper function to add the track to the stream and
+    // dispatch the event ourselves.
+    function addTrackToStreamAndFireEvent(track, stream) {
+        stream.addTrack(track);
+        stream.dispatchEvent(new window.MediaStreamTrackEvent('addtrack',
+            {track: track}));
+    }
+
+    function removeTrackFromStreamAndFireEvent(track, stream) {
+        stream.removeTrack(track);
+        stream.dispatchEvent(new window.MediaStreamTrackEvent('removetrack',
+            {track: track}));
+    }
+
+    function fireAddTrack(pc, track, receiver, streams) {
+        var trackEvent = new Event('track');
+        trackEvent.track = track;
+        trackEvent.receiver = receiver;
+        trackEvent.transceiver = {receiver: receiver};
+        trackEvent.streams = streams;
+        window.setTimeout(function() {
+            pc._dispatchEvent('track', trackEvent);
+        });
+    }
+
+    var RTCPeerConnection = function(config) {
+        var pc = this;
+
+        var _eventTarget = document.createDocumentFragment();
+        ['addEventListener', 'removeEventListener', 'dispatchEvent']
+            .forEach(function(method) {
+                pc[method] = _eventTarget[method].bind(_eventTarget);
+            });
+
+        this.canTrickleIceCandidates = null;
+
+        this.needNegotiation = false;
+
+        this.localStreams = [];
+        this.remoteStreams = [];
+
+        this.localDescription = null;
+        this.remoteDescription = null;
+
+        this.signalingState = 'stable';
+        this.iceConnectionState = 'new';
+        this.connectionState = 'new';
+        this.iceGatheringState = 'new';
+
+        config = JSON.parse(JSON.stringify(config || {}));
+
+        this.usingBundle = config.bundlePolicy === 'max-bundle';
+        if (config.rtcpMuxPolicy === 'negotiate') {
+            throw(makeError('NotSupportedError',
+                'rtcpMuxPolicy \'negotiate\' is not supported'));
+        } else if (!config.rtcpMuxPolicy) {
+            config.rtcpMuxPolicy = 'require';
+        }
+
+        switch (config.iceTransportPolicy) {
+            case 'all':
+            case 'relay':
+                break;
+            default:
+                config.iceTransportPolicy = 'all';
+                break;
+        }
+
+        switch (config.bundlePolicy) {
+            case 'balanced':
+            case 'max-compat':
+            case 'max-bundle':
+                break;
+            default:
+                config.bundlePolicy = 'balanced';
+                break;
+        }
+
+        config.iceServers = filterIceServers(config.iceServers || [], edgeVersion);
+
+        this._iceGatherers = [];
+        if (config.iceCandidatePoolSize) {
+            for (var i = config.iceCandidatePoolSize; i > 0; i--) {
+                this._iceGatherers.push(new window.RTCIceGatherer({
+                    iceServers: config.iceServers,
+                    gatherPolicy: config.iceTransportPolicy
+                }));
+            }
+        } else {
+            config.iceCandidatePoolSize = 0;
+        }
+
+        this._config = config;
+
+        // per-track iceGathers, iceTransports, dtlsTransports, rtpSenders, ...
+        // everything that is needed to describe a SDP m-line.
+        this.transceivers = [];
+
+        this._sdpSessionId = SDPUtils.generateSessionId();
+        this._sdpSessionVersion = 0;
+
+        this._dtlsRole = undefined; // role for a=setup to use in answers.
+
+        this._isClosed = false;
+    };
+
+    // set up event handlers on prototype
+    RTCPeerConnection.prototype.onicecandidate = null;
+    RTCPeerConnection.prototype.onaddstream = null;
+    RTCPeerConnection.prototype.ontrack = null;
+    RTCPeerConnection.prototype.onremovestream = null;
+    RTCPeerConnection.prototype.onsignalingstatechange = null;
+    RTCPeerConnection.prototype.oniceconnectionstatechange = null;
+    RTCPeerConnection.prototype.onconnectionstatechange = null;
+    RTCPeerConnection.prototype.onicegatheringstatechange = null;
+    RTCPeerConnection.prototype.onnegotiationneeded = null;
+    RTCPeerConnection.prototype.ondatachannel = null;
+
+    RTCPeerConnection.prototype._dispatchEvent = function(name, event) {
+        if (this._isClosed) {
+            return;
+        }
+        this.dispatchEvent(event);
+        if (typeof this['on' + name] === 'function') {
+            this['on' + name](event);
+        }
+    };
+
+    RTCPeerConnection.prototype._emitGatheringStateChange = function() {
+        var event = new Event('icegatheringstatechange');
+        this._dispatchEvent('icegatheringstatechange', event);
+    };
+
+    RTCPeerConnection.prototype.getConfiguration = function() {
+        return this._config;
+    };
+
+    RTCPeerConnection.prototype.getLocalStreams = function() {
+        return this.localStreams;
+    };
+
+    RTCPeerConnection.prototype.getRemoteStreams = function() {
+        return this.remoteStreams;
+    };
+
+    // internal helper to create a transceiver object.
+    // (which is not yet the same as the WebRTC 1.0 transceiver)
+    RTCPeerConnection.prototype._createTransceiver = function(kind, doNotAdd) {
+        var hasBundleTransport = this.transceivers.length > 0;
+        var transceiver = {
+            track: null,
+            iceGatherer: null,
+            iceTransport: null,
+            dtlsTransport: null,
+            localCapabilities: null,
+            remoteCapabilities: null,
+            rtpSender: null,
+            rtpReceiver: null,
+            kind: kind,
+            mid: null,
+            sendEncodingParameters: null,
+            recvEncodingParameters: null,
+            stream: null,
+            associatedRemoteMediaStreams: [],
+            wantReceive: true
+        };
+        if (this.usingBundle && hasBundleTransport) {
+            transceiver.iceTransport = this.transceivers[0].iceTransport;
+            transceiver.dtlsTransport = this.transceivers[0].dtlsTransport;
+        } else {
+            var transports = this._createIceAndDtlsTransports();
+            transceiver.iceTransport = transports.iceTransport;
+            transceiver.dtlsTransport = transports.dtlsTransport;
+        }
+        if (!doNotAdd) {
+            this.transceivers.push(transceiver);
+        }
+        return transceiver;
+    };
+
+    RTCPeerConnection.prototype.addTrack = function(track, stream) {
+        if (this._isClosed) {
+            throw makeError('InvalidStateError',
+                'Attempted to call addTrack on a closed peerconnection.');
+        }
+
+        var alreadyExists = this.transceivers.find(function(s) {
+            return s.track === track;
+        });
+
+        if (alreadyExists) {
+            throw makeError('InvalidAccessError', 'Track already exists.');
+        }
+
+        var transceiver;
+        for (var i = 0; i < this.transceivers.length; i++) {
+            if (!this.transceivers[i].track &&
+                this.transceivers[i].kind === track.kind) {
+                transceiver = this.transceivers[i];
+            }
+        }
+        if (!transceiver) {
+            transceiver = this._createTransceiver(track.kind);
+        }
+
+        this._maybeFireNegotiationNeeded();
+
+        if (this.localStreams.indexOf(stream) === -1) {
+            this.localStreams.push(stream);
+        }
+
+        transceiver.track = track;
+        transceiver.stream = stream;
+        transceiver.rtpSender = new window.RTCRtpSender(track,
+            transceiver.dtlsTransport);
+        return transceiver.rtpSender;
+    };
+
+    RTCPeerConnection.prototype.addStream = function(stream) {
+        var pc = this;
+        if (edgeVersion >= 15025) {
+            stream.getTracks().forEach(function(track) {
+                pc.addTrack(track, stream);
+            });
+        } else {
+            // Clone is necessary for local demos mostly, attaching directly
+            // to two different senders does not work (build 10547).
+            // Fixed in 15025 (or earlier)
+            var clonedStream = stream.clone();
+            stream.getTracks().forEach(function(track, idx) {
+                var clonedTrack = clonedStream.getTracks()[idx];
+                track.addEventListener('enabled', function(event) {
+                    clonedTrack.enabled = event.enabled;
+                });
+            });
+            clonedStream.getTracks().forEach(function(track) {
+                pc.addTrack(track, clonedStream);
+            });
+        }
+    };
+
+    RTCPeerConnection.prototype.removeTrack = function(sender) {
+        if (this._isClosed) {
+            throw makeError('InvalidStateError',
+                'Attempted to call removeTrack on a closed peerconnection.');
+        }
+
+        if (!(sender instanceof window.RTCRtpSender)) {
+            throw new TypeError('Argument 1 of RTCPeerConnection.removeTrack ' +
+                'does not implement interface RTCRtpSender.');
+        }
+
+        var transceiver = this.transceivers.find(function(t) {
+            return t.rtpSender === sender;
+        });
+
+        if (!transceiver) {
+            throw makeError('InvalidAccessError',
+                'Sender was not created by this connection.');
+        }
+        var stream = transceiver.stream;
+
+        transceiver.rtpSender.stop();
+        transceiver.rtpSender = null;
+        transceiver.track = null;
+        transceiver.stream = null;
+
+        // remove the stream from the set of local streams
+        var localStreams = this.transceivers.map(function(t) {
+            return t.stream;
+        });
+        if (localStreams.indexOf(stream) === -1 &&
+            this.localStreams.indexOf(stream) > -1) {
+            this.localStreams.splice(this.localStreams.indexOf(stream), 1);
+        }
+
+        this._maybeFireNegotiationNeeded();
+    };
+
+    RTCPeerConnection.prototype.removeStream = function(stream) {
+        var pc = this;
+        stream.getTracks().forEach(function(track) {
+            var sender = pc.getSenders().find(function(s) {
+                return s.track === track;
+            });
+            if (sender) {
+                pc.removeTrack(sender);
+            }
+        });
+    };
+
+    RTCPeerConnection.prototype.getSenders = function() {
+        return this.transceivers.filter(function(transceiver) {
+            return !!transceiver.rtpSender;
+        })
+            .map(function(transceiver) {
+                return transceiver.rtpSender;
+            });
+    };
+
+    RTCPeerConnection.prototype.getReceivers = function() {
+        return this.transceivers.filter(function(transceiver) {
+            return !!transceiver.rtpReceiver;
+        })
+            .map(function(transceiver) {
+                return transceiver.rtpReceiver;
+            });
+    };
+
+
+    RTCPeerConnection.prototype._createIceGatherer = function(sdpMLineIndex,
+                                                              usingBundle) {
+        var pc = this;
+        if (usingBundle && sdpMLineIndex > 0) {
+            return this.transceivers[0].iceGatherer;
+        } else if (this._iceGatherers.length) {
+            return this._iceGatherers.shift();
+        }
+        var iceGatherer = new window.RTCIceGatherer({
+            iceServers: this._config.iceServers,
+            gatherPolicy: this._config.iceTransportPolicy
+        });
+        Object.defineProperty(iceGatherer, 'state',
+            {value: 'new', writable: true}
+        );
+
+        this.transceivers[sdpMLineIndex].bufferedCandidateEvents = [];
+        this.transceivers[sdpMLineIndex].bufferCandidates = function(event) {
+            var end = !event.candidate || Object.keys(event.candidate).length === 0;
+            // polyfill since RTCIceGatherer.state is not implemented in
+            // Edge 10547 yet.
+            iceGatherer.state = end ? 'completed' : 'gathering';
+            if (pc.transceivers[sdpMLineIndex].bufferedCandidateEvents !== null) {
+                pc.transceivers[sdpMLineIndex].bufferedCandidateEvents.push(event);
+            }
+        };
+        iceGatherer.addEventListener('localcandidate',
+            this.transceivers[sdpMLineIndex].bufferCandidates);
+        return iceGatherer;
+    };
+
+    // start gathering from an RTCIceGatherer.
+    RTCPeerConnection.prototype._gather = function(mid, sdpMLineIndex) {
+        var pc = this;
+        var iceGatherer = this.transceivers[sdpMLineIndex].iceGatherer;
+        if (iceGatherer.onlocalcandidate) {
+            return;
+        }
+        var bufferedCandidateEvents =
+            this.transceivers[sdpMLineIndex].bufferedCandidateEvents;
+        this.transceivers[sdpMLineIndex].bufferedCandidateEvents = null;
+        iceGatherer.removeEventListener('localcandidate',
+            this.transceivers[sdpMLineIndex].bufferCandidates);
+        iceGatherer.onlocalcandidate = function(evt) {
+            if (pc.usingBundle && sdpMLineIndex > 0) {
+                // if we know that we use bundle we can drop candidates with
+                // Ñ•dpMLineIndex > 0. If we don't do this then our state gets
+                // confused since we dispose the extra ice gatherer.
+                return;
+            }
+            var event = new Event('icecandidate');
+            event.candidate = {sdpMid: mid, sdpMLineIndex: sdpMLineIndex};
+
+            var cand = evt.candidate;
+            // Edge emits an empty object for RTCIceCandidateComplete‥
+            var end = !cand || Object.keys(cand).length === 0;
+            if (end) {
+                // polyfill since RTCIceGatherer.state is not implemented in
+                // Edge 10547 yet.
+                if (iceGatherer.state === 'new' || iceGatherer.state === 'gathering') {
+                    iceGatherer.state = 'completed';
+                }
+            } else {
+                if (iceGatherer.state === 'new') {
+                    iceGatherer.state = 'gathering';
+                }
+                // RTCIceCandidate doesn't have a component, needs to be added
+                cand.component = 1;
+                // also the usernameFragment. TODO: update SDP to take both variants.
+                cand.ufrag = iceGatherer.getLocalParameters().usernameFragment;
+
+                var serializedCandidate = SDPUtils.writeCandidate(cand);
+                event.candidate = Object.assign(event.candidate,
+                    SDPUtils.parseCandidate(serializedCandidate));
+
+                event.candidate.candidate = serializedCandidate;
+                event.candidate.toJSON = function() {
+                    return {
+                        candidate: event.candidate.candidate,
+                        sdpMid: event.candidate.sdpMid,
+                        sdpMLineIndex: event.candidate.sdpMLineIndex,
+                        usernameFragment: event.candidate.usernameFragment
+                    };
+                };
+            }
+
+            // update local description.
+            var sections = SDPUtils.getMediaSections(pc.localDescription.sdp);
+            if (!end) {
+                sections[event.candidate.sdpMLineIndex] +=
+                    'a=' + event.candidate.candidate + '\r\n';
+            } else {
+                sections[event.candidate.sdpMLineIndex] +=
+                    'a=end-of-candidates\r\n';
+            }
+            pc.localDescription.sdp =
+                SDPUtils.getDescription(pc.localDescription.sdp) +
+                sections.join('');
+            var complete = pc.transceivers.every(function(transceiver) {
+                return transceiver.iceGatherer &&
+                    transceiver.iceGatherer.state === 'completed';
+            });
+
+            if (pc.iceGatheringState !== 'gathering') {
+                pc.iceGatheringState = 'gathering';
+                pc._emitGatheringStateChange();
+            }
+
+            // Emit candidate. Also emit null candidate when all gatherers are
+            // complete.
+            if (!end) {
+                pc._dispatchEvent('icecandidate', event);
+            }
+            if (complete) {
+                pc._dispatchEvent('icecandidate', new Event('icecandidate'));
+                pc.iceGatheringState = 'complete';
+                pc._emitGatheringStateChange();
+            }
+        };
+
+        // emit already gathered candidates.
+        window.setTimeout(function() {
+            bufferedCandidateEvents.forEach(function(e) {
+                iceGatherer.onlocalcandidate(e);
+            });
+        }, 0);
+    };
+
+    // Create ICE transport and DTLS transport.
+    RTCPeerConnection.prototype._createIceAndDtlsTransports = function() {
+        var pc = this;
+        var iceTransport = new window.RTCIceTransport(null);
+        iceTransport.onicestatechange = function() {
+            pc._updateIceConnectionState();
+            pc._updateConnectionState();
+        };
+
+        var dtlsTransport = new window.RTCDtlsTransport(iceTransport);
+        dtlsTransport.ondtlsstatechange = function() {
+            pc._updateConnectionState();
+        };
+        dtlsTransport.onerror = function() {
+            // onerror does not set state to failed by itself.
+            Object.defineProperty(dtlsTransport, 'state',
+                {value: 'failed', writable: true});
+            pc._updateConnectionState();
+        };
+
+        return {
+            iceTransport: iceTransport,
+            dtlsTransport: dtlsTransport
+        };
+    };
+
+    // Destroy ICE gatherer, ICE transport and DTLS transport.
+    // Without triggering the callbacks.
+    RTCPeerConnection.prototype._disposeIceAndDtlsTransports = function(
+        sdpMLineIndex) {
+        var iceGatherer = this.transceivers[sdpMLineIndex].iceGatherer;
+        if (iceGatherer) {
+            delete iceGatherer.onlocalcandidate;
+            delete this.transceivers[sdpMLineIndex].iceGatherer;
+        }
+        var iceTransport = this.transceivers[sdpMLineIndex].iceTransport;
+        if (iceTransport) {
+            delete iceTransport.onicestatechange;
+            delete this.transceivers[sdpMLineIndex].iceTransport;
+        }
+        var dtlsTransport = this.transceivers[sdpMLineIndex].dtlsTransport;
+        if (dtlsTransport) {
+            delete dtlsTransport.ondtlsstatechange;
+            delete dtlsTransport.onerror;
+            delete this.transceivers[sdpMLineIndex].dtlsTransport;
+        }
+    };
+
+    // Start the RTP Sender and Receiver for a transceiver.
+    RTCPeerConnection.prototype._transceive = function(transceiver,
+                                                       send, recv) {
+        var params = getCommonCapabilities(transceiver.localCapabilities,
+            transceiver.remoteCapabilities);
+        if (send && transceiver.rtpSender) {
+            params.encodings = transceiver.sendEncodingParameters;
+            params.rtcp = {
+                cname: SDPUtils.localCName,
+                compound: transceiver.rtcpParameters.compound
+            };
+            if (transceiver.recvEncodingParameters.length) {
+                params.rtcp.ssrc = transceiver.recvEncodingParameters[0].ssrc;
+            }
+            transceiver.rtpSender.send(params);
+        }
+        if (recv && transceiver.rtpReceiver && params.codecs.length > 0) {
+            // remove RTX field in Edge 14942
+            if (transceiver.kind === 'video'
+                && transceiver.recvEncodingParameters
+                && edgeVersion < 15019) {
+                transceiver.recvEncodingParameters.forEach(function(p) {
+                    delete p.rtx;
+                });
+            }
+            if (transceiver.recvEncodingParameters.length) {
+                params.encodings = transceiver.recvEncodingParameters;
+            } else {
+                params.encodings = [{}];
+            }
+            params.rtcp = {
+                compound: transceiver.rtcpParameters.compound
+            };
+            if (transceiver.rtcpParameters.cname) {
+                params.rtcp.cname = transceiver.rtcpParameters.cname;
+            }
+            if (transceiver.sendEncodingParameters.length) {
+                params.rtcp.ssrc = transceiver.sendEncodingParameters[0].ssrc;
+            }
+            transceiver.rtpReceiver.receive(params);
+        }
+    };
+
+    RTCPeerConnection.prototype.setLocalDescription = function(description) {
+        var pc = this;
+
+        // Note: pranswer is not supported.
+        if (['offer', 'answer'].indexOf(description.type) === -1) {
+            return Promise.reject(makeError('TypeError',
+                'Unsupported type "' + description.type + '"'));
+        }
+
+        if (!isActionAllowedInSignalingState('setLocalDescription',
+            description.type, pc.signalingState) || pc._isClosed) {
+            return Promise.reject(makeError('InvalidStateError',
+                'Can not set local ' + description.type +
+                ' in state ' + pc.signalingState));
+        }
+
+        var sections;
+        var sessionpart;
+        if (description.type === 'offer') {
+            // VERY limited support for SDP munging. Limited to:
+            // * changing the order of codecs
+            sections = SDPUtils.splitSections(description.sdp);
+            sessionpart = sections.shift();
+            sections.forEach(function(mediaSection, sdpMLineIndex) {
+                var caps = SDPUtils.parseRtpParameters(mediaSection);
+                pc.transceivers[sdpMLineIndex].localCapabilities = caps;
+            });
+
+            pc.transceivers.forEach(function(transceiver, sdpMLineIndex) {
+                pc._gather(transceiver.mid, sdpMLineIndex);
+            });
+        } else if (description.type === 'answer') {
+            sections = SDPUtils.splitSections(pc.remoteDescription.sdp);
+            sessionpart = sections.shift();
+            var isIceLite = SDPUtils.matchPrefix(sessionpart,
+                'a=ice-lite').length > 0;
+            sections.forEach(function(mediaSection, sdpMLineIndex) {
+                var transceiver = pc.transceivers[sdpMLineIndex];
+                var iceGatherer = transceiver.iceGatherer;
+                var iceTransport = transceiver.iceTransport;
+                var dtlsTransport = transceiver.dtlsTransport;
+                var localCapabilities = transceiver.localCapabilities;
+                var remoteCapabilities = transceiver.remoteCapabilities;
+
+                // treat bundle-only as not-rejected.
+                var rejected = SDPUtils.isRejected(mediaSection) &&
+                    SDPUtils.matchPrefix(mediaSection, 'a=bundle-only').length === 0;
+
+                if (!rejected && !transceiver.rejected) {
+                    var remoteIceParameters = SDPUtils.getIceParameters(
+                        mediaSection, sessionpart);
+                    var remoteDtlsParameters = SDPUtils.getDtlsParameters(
+                        mediaSection, sessionpart);
+                    if (isIceLite) {
+                        remoteDtlsParameters.role = 'server';
+                    }
+
+                    if (!pc.usingBundle || sdpMLineIndex === 0) {
+                        pc._gather(transceiver.mid, sdpMLineIndex);
+                        if (iceTransport.state === 'new') {
+                            iceTransport.start(iceGatherer, remoteIceParameters,
+                                isIceLite ? 'controlling' : 'controlled');
+                        }
+                        if (dtlsTransport.state === 'new') {
+                            dtlsTransport.start(remoteDtlsParameters);
+                        }
+                    }
+
+                    // Calculate intersection of capabilities.
+                    var params = getCommonCapabilities(localCapabilities,
+                        remoteCapabilities);
+
+                    // Start the RTCRtpSender. The RTCRtpReceiver for this
+                    // transceiver has already been started in setRemoteDescription.
+                    pc._transceive(transceiver,
+                        params.codecs.length > 0,
+                        false);
+                }
+            });
+        }
+
+        pc.localDescription = {
+            type: description.type,
+            sdp: description.sdp
+        };
+        if (description.type === 'offer') {
+            pc._updateSignalingState('have-local-offer');
+        } else {
+            pc._updateSignalingState('stable');
+        }
+
+        return Promise.resolve();
+    };
+
+    RTCPeerConnection.prototype.setRemoteDescription = function(description) {
+        var pc = this;
+
+        // Note: pranswer is not supported.
+        if (['offer', 'answer'].indexOf(description.type) === -1) {
+            return Promise.reject(makeError('TypeError',
+                'Unsupported type "' + description.type + '"'));
+        }
+
+        if (!isActionAllowedInSignalingState('setRemoteDescription',
+            description.type, pc.signalingState) || pc._isClosed) {
+            return Promise.reject(makeError('InvalidStateError',
+                'Can not set remote ' + description.type +
+                ' in state ' + pc.signalingState));
+        }
+
+        var streams = {};
+        pc.remoteStreams.forEach(function(stream) {
+            streams[stream.id] = stream;
+        });
+        var receiverList = [];
+        var sections = SDPUtils.splitSections(description.sdp);
+        var sessionpart = sections.shift();
+        var isIceLite = SDPUtils.matchPrefix(sessionpart,
+            'a=ice-lite').length > 0;
+        var usingBundle = SDPUtils.matchPrefix(sessionpart,
+            'a=group:BUNDLE ').length > 0;
+        pc.usingBundle = usingBundle;
+        var iceOptions = SDPUtils.matchPrefix(sessionpart,
+            'a=ice-options:')[0];
+        if (iceOptions) {
+            pc.canTrickleIceCandidates = iceOptions.substr(14).split(' ')
+                .indexOf('trickle') >= 0;
+        } else {
+            pc.canTrickleIceCandidates = false;
+        }
+
+        sections.forEach(function(mediaSection, sdpMLineIndex) {
+            var lines = SDPUtils.splitLines(mediaSection);
+            var kind = SDPUtils.getKind(mediaSection);
+            // treat bundle-only as not-rejected.
+            var rejected = SDPUtils.isRejected(mediaSection) &&
+                SDPUtils.matchPrefix(mediaSection, 'a=bundle-only').length === 0;
+            var protocol = lines[0].substr(2).split(' ')[2];
+
+            var direction = SDPUtils.getDirection(mediaSection, sessionpart);
+            var remoteMsid = SDPUtils.parseMsid(mediaSection);
+
+            var mid = SDPUtils.getMid(mediaSection) || SDPUtils.generateIdentifier();
+
+            // Reject datachannels which are not implemented yet.
+            if ((kind === 'application' && protocol === 'DTLS/SCTP') || rejected) {
+                // TODO: this is dangerous in the case where a non-rejected m-line
+                //     becomes rejected.
+                pc.transceivers[sdpMLineIndex] = {
+                    mid: mid,
+                    kind: kind,
+                    rejected: true
+                };
+                return;
+            }
+
+            if (!rejected && pc.transceivers[sdpMLineIndex] &&
+                pc.transceivers[sdpMLineIndex].rejected) {
+                // recycle a rejected transceiver.
+                pc.transceivers[sdpMLineIndex] = pc._createTransceiver(kind, true);
+            }
+
+            var transceiver;
+            var iceGatherer;
+            var iceTransport;
+            var dtlsTransport;
+            var rtpReceiver;
+            var sendEncodingParameters;
+            var recvEncodingParameters;
+            var localCapabilities;
+
+            var track;
+            // FIXME: ensure the mediaSection has rtcp-mux set.
+            var remoteCapabilities = SDPUtils.parseRtpParameters(mediaSection);
+            var remoteIceParameters;
+            var remoteDtlsParameters;
+            if (!rejected) {
+                remoteIceParameters = SDPUtils.getIceParameters(mediaSection,
+                    sessionpart);
+                remoteDtlsParameters = SDPUtils.getDtlsParameters(mediaSection,
+                    sessionpart);
+                remoteDtlsParameters.role = 'client';
+            }
+            recvEncodingParameters =
+                SDPUtils.parseRtpEncodingParameters(mediaSection);
+
+            var rtcpParameters = SDPUtils.parseRtcpParameters(mediaSection);
+
+            var isComplete = SDPUtils.matchPrefix(mediaSection,
+                'a=end-of-candidates', sessionpart).length > 0;
+            var cands = SDPUtils.matchPrefix(mediaSection, 'a=candidate:')
+                .map(function(cand) {
+                    return SDPUtils.parseCandidate(cand);
+                })
+                .filter(function(cand) {
+                    return cand.component === 1;
+                });
+
+            // Check if we can use BUNDLE and dispose transports.
+            if ((description.type === 'offer' || description.type === 'answer') &&
+                !rejected && usingBundle && sdpMLineIndex > 0 &&
+                pc.transceivers[sdpMLineIndex]) {
+                pc._disposeIceAndDtlsTransports(sdpMLineIndex);
+                pc.transceivers[sdpMLineIndex].iceGatherer =
+                    pc.transceivers[0].iceGatherer;
+                pc.transceivers[sdpMLineIndex].iceTransport =
+                    pc.transceivers[0].iceTransport;
+                pc.transceivers[sdpMLineIndex].dtlsTransport =
+                    pc.transceivers[0].dtlsTransport;
+                if (pc.transceivers[sdpMLineIndex].rtpSender) {
+                    pc.transceivers[sdpMLineIndex].rtpSender.setTransport(
+                        pc.transceivers[0].dtlsTransport);
+                }
+                if (pc.transceivers[sdpMLineIndex].rtpReceiver) {
+                    pc.transceivers[sdpMLineIndex].rtpReceiver.setTransport(
+                        pc.transceivers[0].dtlsTransport);
+                }
+            }
+            if (description.type === 'offer' && !rejected) {
+                transceiver = pc.transceivers[sdpMLineIndex] ||
+                    pc._createTransceiver(kind);
+                transceiver.mid = mid;
+
+                if (!transceiver.iceGatherer) {
+                    transceiver.iceGatherer = pc._createIceGatherer(sdpMLineIndex,
+                        usingBundle);
+                }
+
+                if (cands.length && transceiver.iceTransport.state === 'new') {
+                    if (isComplete && (!usingBundle || sdpMLineIndex === 0)) {
+                        transceiver.iceTransport.setRemoteCandidates(cands);
+                    } else {
+                        cands.forEach(function(candidate) {
+                            maybeAddCandidate(transceiver.iceTransport, candidate);
+                        });
+                    }
+                }
+
+                localCapabilities = window.RTCRtpReceiver.getCapabilities(kind);
+
+                // filter RTX until additional stuff needed for RTX is implemented
+                // in adapter.js
+                if (edgeVersion < 15019) {
+                    localCapabilities.codecs = localCapabilities.codecs.filter(
+                        function(codec) {
+                            return codec.name !== 'rtx';
+                        });
+                }
+
+                sendEncodingParameters = transceiver.sendEncodingParameters || [{
+                    ssrc: (2 * sdpMLineIndex + 2) * 1001
+                }];
+
+                // TODO: rewrite to use http://w3c.github.io/webrtc-pc/#set-associated-remote-streams
+                var isNewTrack = false;
+                if (direction === 'sendrecv' || direction === 'sendonly') {
+                    isNewTrack = !transceiver.rtpReceiver;
+                    rtpReceiver = transceiver.rtpReceiver ||
+                        new window.RTCRtpReceiver(transceiver.dtlsTransport, kind);
+
+                    if (isNewTrack) {
+                        var stream;
+                        track = rtpReceiver.track;
+                        // FIXME: does not work with Plan B.
+                        if (remoteMsid && remoteMsid.stream === '-') {
+                            // no-op. a stream id of '-' means: no associated stream.
+                        } else if (remoteMsid) {
+                            if (!streams[remoteMsid.stream]) {
+                                streams[remoteMsid.stream] = new window.MediaStream();
+                                Object.defineProperty(streams[remoteMsid.stream], 'id', {
+                                    get: function() {
+                                        return remoteMsid.stream;
+                                    }
+                                });
+                            }
+                            Object.defineProperty(track, 'id', {
+                                get: function() {
+                                    return remoteMsid.track;
+                                }
+                            });
+                            stream = streams[remoteMsid.stream];
+                        } else {
+                            if (!streams.default) {
+                                streams.default = new window.MediaStream();
+                            }
+                            stream = streams.default;
+                        }
+                        if (stream) {
+                            addTrackToStreamAndFireEvent(track, stream);
+                            transceiver.associatedRemoteMediaStreams.push(stream);
+                        }
+                        receiverList.push([track, rtpReceiver, stream]);
+                    }
+                } else if (transceiver.rtpReceiver && transceiver.rtpReceiver.track) {
+                    transceiver.associatedRemoteMediaStreams.forEach(function(s) {
+                        var nativeTrack = s.getTracks().find(function(t) {
+                            return t.id === transceiver.rtpReceiver.track.id;
+                        });
+                        if (nativeTrack) {
+                            removeTrackFromStreamAndFireEvent(nativeTrack, s);
+                        }
+                    });
+                    transceiver.associatedRemoteMediaStreams = [];
+                }
+
+                transceiver.localCapabilities = localCapabilities;
+                transceiver.remoteCapabilities = remoteCapabilities;
+                transceiver.rtpReceiver = rtpReceiver;
+                transceiver.rtcpParameters = rtcpParameters;
+                transceiver.sendEncodingParameters = sendEncodingParameters;
+                transceiver.recvEncodingParameters = recvEncodingParameters;
+
+                // Start the RTCRtpReceiver now. The RTPSender is started in
+                // setLocalDescription.
+                pc._transceive(pc.transceivers[sdpMLineIndex],
+                    false,
+                    isNewTrack);
+            } else if (description.type === 'answer' && !rejected) {
+                transceiver = pc.transceivers[sdpMLineIndex];
+                iceGatherer = transceiver.iceGatherer;
+                iceTransport = transceiver.iceTransport;
+                dtlsTransport = transceiver.dtlsTransport;
+                rtpReceiver = transceiver.rtpReceiver;
+                sendEncodingParameters = transceiver.sendEncodingParameters;
+                localCapabilities = transceiver.localCapabilities;
+
+                pc.transceivers[sdpMLineIndex].recvEncodingParameters =
+                    recvEncodingParameters;
+                pc.transceivers[sdpMLineIndex].remoteCapabilities =
+                    remoteCapabilities;
+                pc.transceivers[sdpMLineIndex].rtcpParameters = rtcpParameters;
+
+                if (cands.length && iceTransport.state === 'new') {
+                    if ((isIceLite || isComplete) &&
+                        (!usingBundle || sdpMLineIndex === 0)) {
+                        iceTransport.setRemoteCandidates(cands);
+                    } else {
+                        cands.forEach(function(candidate) {
+                            maybeAddCandidate(transceiver.iceTransport, candidate);
+                        });
+                    }
+                }
+
+                if (!usingBundle || sdpMLineIndex === 0) {
+                    if (iceTransport.state === 'new') {
+                        iceTransport.start(iceGatherer, remoteIceParameters,
+                            'controlling');
+                    }
+                    if (dtlsTransport.state === 'new') {
+                        dtlsTransport.start(remoteDtlsParameters);
+                    }
+                }
+
+                pc._transceive(transceiver,
+                    direction === 'sendrecv' || direction === 'recvonly',
+                    direction === 'sendrecv' || direction === 'sendonly');
+
+                // TODO: rewrite to use http://w3c.github.io/webrtc-pc/#set-associated-remote-streams
+                if (rtpReceiver &&
+                    (direction === 'sendrecv' || direction === 'sendonly')) {
+                    track = rtpReceiver.track;
+                    if (remoteMsid) {
+                        if (!streams[remoteMsid.stream]) {
+                            streams[remoteMsid.stream] = new window.MediaStream();
+                        }
+                        addTrackToStreamAndFireEvent(track, streams[remoteMsid.stream]);
+                        receiverList.push([track, rtpReceiver, streams[remoteMsid.stream]]);
+                    } else {
+                        if (!streams.default) {
+                            streams.default = new window.MediaStream();
+                        }
+                        addTrackToStreamAndFireEvent(track, streams.default);
+                        receiverList.push([track, rtpReceiver, streams.default]);
+                    }
+                } else {
+                    // FIXME: actually the receiver should be created later.
+                    delete transceiver.rtpReceiver;
+                }
+            }
+        });
+
+        if (pc._dtlsRole === undefined) {
+            pc._dtlsRole = description.type === 'offer' ? 'active' : 'passive';
+        }
+
+        pc.remoteDescription = {
+            type: description.type,
+            sdp: description.sdp
+        };
+        if (description.type === 'offer') {
+            pc._updateSignalingState('have-remote-offer');
+        } else {
+            pc._updateSignalingState('stable');
+        }
+        Object.keys(streams).forEach(function(sid) {
+            var stream = streams[sid];
+            if (stream.getTracks().length) {
+                if (pc.remoteStreams.indexOf(stream) === -1) {
+                    pc.remoteStreams.push(stream);
+                    var event = new Event('addstream');
+                    event.stream = stream;
+                    window.setTimeout(function() {
+                        pc._dispatchEvent('addstream', event);
+                    });
+                }
+
+                receiverList.forEach(function(item) {
+                    var track = item[0];
+                    var receiver = item[1];
+                    if (stream.id !== item[2].id) {
+                        return;
+                    }
+                    fireAddTrack(pc, track, receiver, [stream]);
+                });
+            }
+        });
+        receiverList.forEach(function(item) {
+            if (item[2]) {
+                return;
+            }
+            fireAddTrack(pc, item[0], item[1], []);
+        });
+
+        // check whether addIceCandidate({}) was called within four seconds after
+        // setRemoteDescription.
+        window.setTimeout(function() {
+            if (!(pc && pc.transceivers)) {
+                return;
+            }
+            pc.transceivers.forEach(function(transceiver) {
+                if (transceiver.iceTransport &&
+                    transceiver.iceTransport.state === 'new' &&
+                    transceiver.iceTransport.getRemoteCandidates().length > 0) {
+                    console.warn('Timeout for addRemoteCandidate. Consider sending ' +
+                        'an end-of-candidates notification');
+                    transceiver.iceTransport.addRemoteCandidate({});
+                }
+            });
+        }, 4000);
+
+        return Promise.resolve();
+    };
+
+    RTCPeerConnection.prototype.close = function() {
+        this.transceivers.forEach(function(transceiver) {
+            /* not yet
+if (transceiver.iceGatherer) {
+transceiver.iceGatherer.close();
+}
+*/
+            if (transceiver.iceTransport) {
+                transceiver.iceTransport.stop();
+            }
+            if (transceiver.dtlsTransport) {
+                transceiver.dtlsTransport.stop();
+            }
+            if (transceiver.rtpSender) {
+                transceiver.rtpSender.stop();
+            }
+            if (transceiver.rtpReceiver) {
+                transceiver.rtpReceiver.stop();
+            }
+        });
+        // FIXME: clean up tracks, local streams, remote streams, etc
+        this._isClosed = true;
+        this._updateSignalingState('closed');
+    };
+
+    // Update the signaling state.
+    RTCPeerConnection.prototype._updateSignalingState = function(newState) {
+        this.signalingState = newState;
+        var event = new Event('signalingstatechange');
+        this._dispatchEvent('signalingstatechange', event);
+    };
+
+    // Determine whether to fire the negotiationneeded event.
+    RTCPeerConnection.prototype._maybeFireNegotiationNeeded = function() {
+        var pc = this;
+        if (this.signalingState !== 'stable' || this.needNegotiation === true) {
+            return;
+        }
+        this.needNegotiation = true;
+        window.setTimeout(function() {
+            if (pc.needNegotiation) {
+                pc.needNegotiation = false;
+                var event = new Event('negotiationneeded');
+                pc._dispatchEvent('negotiationneeded', event);
+            }
+        }, 0);
+    };
+
+    // Update the ice connection state.
+    RTCPeerConnection.prototype._updateIceConnectionState = function() {
+        var newState;
+        var states = {
+            'new': 0,
+            closed: 0,
+            checking: 0,
+            connected: 0,
+            completed: 0,
+            disconnected: 0,
+            failed: 0
+        };
+        this.transceivers.forEach(function(transceiver) {
+            states[transceiver.iceTransport.state]++;
+        });
+
+        newState = 'new';
+        if (states.failed > 0) {
+            newState = 'failed';
+        } else if (states.checking > 0) {
+            newState = 'checking';
+        } else if (states.disconnected > 0) {
+            newState = 'disconnected';
+        } else if (states.new > 0) {
+            newState = 'new';
+        } else if (states.connected > 0) {
+            newState = 'connected';
+        } else if (states.completed > 0) {
+            newState = 'completed';
+        }
+
+        if (newState !== this.iceConnectionState) {
+            this.iceConnectionState = newState;
+            var event = new Event('iceconnectionstatechange');
+            this._dispatchEvent('iceconnectionstatechange', event);
+        }
+    };
+
+    // Update the connection state.
+    RTCPeerConnection.prototype._updateConnectionState = function() {
+        var newState;
+        var states = {
+            'new': 0,
+            closed: 0,
+            connecting: 0,
+            connected: 0,
+            completed: 0,
+            disconnected: 0,
+            failed: 0
+        };
+        this.transceivers.forEach(function(transceiver) {
+            states[transceiver.iceTransport.state]++;
+            states[transceiver.dtlsTransport.state]++;
+        });
+        // ICETransport.completed and connected are the same for this purpose.
+        states.connected += states.completed;
+
+        newState = 'new';
+        if (states.failed > 0) {
+            newState = 'failed';
+        } else if (states.connecting > 0) {
+            newState = 'connecting';
+        } else if (states.disconnected > 0) {
+            newState = 'disconnected';
+        } else if (states.new > 0) {
+            newState = 'new';
+        } else if (states.connected > 0) {
+            newState = 'connected';
+        }
+
+        if (newState !== this.connectionState) {
+            this.connectionState = newState;
+            var event = new Event('connectionstatechange');
+            this._dispatchEvent('connectionstatechange', event);
+        }
+    };
+
+    RTCPeerConnection.prototype.createOffer = function() {
+        var pc = this;
+
+        if (pc._isClosed) {
+            return Promise.reject(makeError('InvalidStateError',
+                'Can not call createOffer after close'));
+        }
+
+        var numAudioTracks = pc.transceivers.filter(function(t) {
+            return t.kind === 'audio';
+        }).length;
+        var numVideoTracks = pc.transceivers.filter(function(t) {
+            return t.kind === 'video';
+        }).length;
+
+        // Determine number of audio and video tracks we need to send/recv.
+        var offerOptions = arguments[0];
+        if (offerOptions) {
+            // Reject Chrome legacy constraints.
+            if (offerOptions.mandatory || offerOptions.optional) {
+                throw new TypeError(
+                    'Legacy mandatory/optional constraints not supported.');
+            }
+            if (offerOptions.offerToReceiveAudio !== undefined) {
+                if (offerOptions.offerToReceiveAudio === true) {
+                    numAudioTracks = 1;
+                } else if (offerOptions.offerToReceiveAudio === false) {
+                    numAudioTracks = 0;
+                } else {
+                    numAudioTracks = offerOptions.offerToReceiveAudio;
+                }
+            }
+            if (offerOptions.offerToReceiveVideo !== undefined) {
+                if (offerOptions.offerToReceiveVideo === true) {
+                    numVideoTracks = 1;
+                } else if (offerOptions.offerToReceiveVideo === false) {
+                    numVideoTracks = 0;
+                } else {
+                    numVideoTracks = offerOptions.offerToReceiveVideo;
+                }
+            }
+        }
+
+        pc.transceivers.forEach(function(transceiver) {
+            if (transceiver.kind === 'audio') {
+                numAudioTracks--;
+                if (numAudioTracks < 0) {
+                    transceiver.wantReceive = false;
+                }
+            } else if (transceiver.kind === 'video') {
+                numVideoTracks--;
+                if (numVideoTracks < 0) {
+                    transceiver.wantReceive = false;
+                }
+            }
+        });
+
+        // Create M-lines for recvonly streams.
+        while (numAudioTracks > 0 || numVideoTracks > 0) {
+            if (numAudioTracks > 0) {
+                pc._createTransceiver('audio');
+                numAudioTracks--;
+            }
+            if (numVideoTracks > 0) {
+                pc._createTransceiver('video');
+                numVideoTracks--;
+            }
+        }
+
+        var sdp = SDPUtils.writeSessionBoilerplate(pc._sdpSessionId,
+            pc._sdpSessionVersion++);
+        pc.transceivers.forEach(function(transceiver, sdpMLineIndex) {
+            // For each track, create an ice gatherer, ice transport,
+            // dtls transport, potentially rtpsender and rtpreceiver.
+            var track = transceiver.track;
+            var kind = transceiver.kind;
+            var mid = transceiver.mid || SDPUtils.generateIdentifier();
+            transceiver.mid = mid;
+
+            if (!transceiver.iceGatherer) {
+                transceiver.iceGatherer = pc._createIceGatherer(sdpMLineIndex,
+                    pc.usingBundle);
+            }
+
+            var localCapabilities = window.RTCRtpSender.getCapabilities(kind);
+            // filter RTX until additional stuff needed for RTX is implemented
+            // in adapter.js
+            if (edgeVersion < 15019) {
+                localCapabilities.codecs = localCapabilities.codecs.filter(
+                    function(codec) {
+                        return codec.name !== 'rtx';
+                    });
+            }
+            localCapabilities.codecs.forEach(function(codec) {
+                // work around https://bugs.chromium.org/p/webrtc/issues/detail?id=6552
+                // by adding level-asymmetry-allowed=1
+                if (codec.name === 'H264' &&
+                    codec.parameters['level-asymmetry-allowed'] === undefined) {
+                    codec.parameters['level-asymmetry-allowed'] = '1';
+                }
+
+                // for subsequent offers, we might have to re-use the payload
+                // type of the last offer.
+                if (transceiver.remoteCapabilities &&
+                    transceiver.remoteCapabilities.codecs) {
+                    transceiver.remoteCapabilities.codecs.forEach(function(remoteCodec) {
+                        if (codec.name.toLowerCase() === remoteCodec.name.toLowerCase() &&
+                            codec.clockRate === remoteCodec.clockRate) {
+                            codec.preferredPayloadType = remoteCodec.payloadType;
+                        }
+                    });
+                }
+            });
+            localCapabilities.headerExtensions.forEach(function(hdrExt) {
+                var remoteExtensions = transceiver.remoteCapabilities &&
+                    transceiver.remoteCapabilities.headerExtensions || [];
+                remoteExtensions.forEach(function(rHdrExt) {
+                    if (hdrExt.uri === rHdrExt.uri) {
+                        hdrExt.id = rHdrExt.id;
+                    }
+                });
+            });
+
+            // generate an ssrc now, to be used later in rtpSender.send
+            var sendEncodingParameters = transceiver.sendEncodingParameters || [{
+                ssrc: (2 * sdpMLineIndex + 1) * 1001
+            }];
+            if (track) {
+                // add RTX
+                if (edgeVersion >= 15019 && kind === 'video' &&
+                    !sendEncodingParameters[0].rtx) {
+                    sendEncodingParameters[0].rtx = {
+                        ssrc: sendEncodingParameters[0].ssrc + 1
+                    };
+                }
+            }
+
+            if (transceiver.wantReceive) {
+                transceiver.rtpReceiver = new window.RTCRtpReceiver(
+                    transceiver.dtlsTransport, kind);
+            }
+
+            transceiver.localCapabilities = localCapabilities;
+            transceiver.sendEncodingParameters = sendEncodingParameters;
+        });
+
+        // always offer BUNDLE and dispose on return if not supported.
+        if (pc._config.bundlePolicy !== 'max-compat') {
+            sdp += 'a=group:BUNDLE ' + pc.transceivers.map(function(t) {
+                return t.mid;
+            }).join(' ') + '\r\n';
+        }
+        sdp += 'a=ice-options:trickle\r\n';
+
+        pc.transceivers.forEach(function(transceiver, sdpMLineIndex) {
+            sdp += writeMediaSection(transceiver, transceiver.localCapabilities,
+                'offer', transceiver.stream, pc._dtlsRole);
+            sdp += 'a=rtcp-rsize\r\n';
+
+            if (transceiver.iceGatherer && pc.iceGatheringState !== 'new' &&
+                (sdpMLineIndex === 0 || !pc.usingBundle)) {
+                transceiver.iceGatherer.getLocalCandidates().forEach(function(cand) {
+                    cand.component = 1;
+                    sdp += 'a=' + SDPUtils.writeCandidate(cand) + '\r\n';
+                });
+
+                if (transceiver.iceGatherer.state === 'completed') {
+                    sdp += 'a=end-of-candidates\r\n';
+                }
+            }
+        });
+
+        var desc = new window.RTCSessionDescription({
+            type: 'offer',
+            sdp: sdp
+        });
+        return Promise.resolve(desc);
+    };
+
+    RTCPeerConnection.prototype.createAnswer = function() {
+        var pc = this;
+
+        if (pc._isClosed) {
+            return Promise.reject(makeError('InvalidStateError',
+                'Can not call createAnswer after close'));
+        }
+
+        if (!(pc.signalingState === 'have-remote-offer' ||
+            pc.signalingState === 'have-local-pranswer')) {
+            return Promise.reject(makeError('InvalidStateError',
+                'Can not call createAnswer in signalingState ' + pc.signalingState));
+        }
+
+        var sdp = SDPUtils.writeSessionBoilerplate(pc._sdpSessionId,
+            pc._sdpSessionVersion++);
+        if (pc.usingBundle) {
+            sdp += 'a=group:BUNDLE ' + pc.transceivers.map(function(t) {
+                return t.mid;
+            }).join(' ') + '\r\n';
+        }
+        var mediaSectionsInOffer = SDPUtils.getMediaSections(
+            pc.remoteDescription.sdp).length;
+        pc.transceivers.forEach(function(transceiver, sdpMLineIndex) {
+            if (sdpMLineIndex + 1 > mediaSectionsInOffer) {
+                return;
+            }
+            if (transceiver.rejected) {
+                if (transceiver.kind === 'application') {
+                    sdp += 'm=application 0 DTLS/SCTP 5000\r\n';
+                } else if (transceiver.kind === 'audio') {
+                    sdp += 'm=audio 0 UDP/TLS/RTP/SAVPF 0\r\n' +
+                        'a=rtpmap:0 PCMU/8000\r\n';
+                } else if (transceiver.kind === 'video') {
+                    sdp += 'm=video 0 UDP/TLS/RTP/SAVPF 120\r\n' +
+                        'a=rtpmap:120 VP8/90000\r\n';
+                }
+                sdp += 'c=IN IP4 0.0.0.0\r\n' +
+                    'a=inactive\r\n' +
+                    'a=mid:' + transceiver.mid + '\r\n';
+                return;
+            }
+
+            // FIXME: look at direction.
+            if (transceiver.stream) {
+                var localTrack;
+                if (transceiver.kind === 'audio') {
+                    localTrack = transceiver.stream.getAudioTracks()[0];
+                } else if (transceiver.kind === 'video') {
+                    localTrack = transceiver.stream.getVideoTracks()[0];
+                }
+                if (localTrack) {
+                    // add RTX
+                    if (edgeVersion >= 15019 && transceiver.kind === 'video' &&
+                        !transceiver.sendEncodingParameters[0].rtx) {
+                        transceiver.sendEncodingParameters[0].rtx = {
+                            ssrc: transceiver.sendEncodingParameters[0].ssrc + 1
+                        };
+                    }
+                }
+            }
+
+            // Calculate intersection of capabilities.
+            var commonCapabilities = getCommonCapabilities(
+                transceiver.localCapabilities,
+                transceiver.remoteCapabilities);
+
+            var hasRtx = commonCapabilities.codecs.filter(function(c) {
+                return c.name.toLowerCase() === 'rtx';
+            }).length;
+            if (!hasRtx && transceiver.sendEncodingParameters[0].rtx) {
+                delete transceiver.sendEncodingParameters[0].rtx;
+            }
+
+            sdp += writeMediaSection(transceiver, commonCapabilities,
+                'answer', transceiver.stream, pc._dtlsRole);
+            if (transceiver.rtcpParameters &&
+                transceiver.rtcpParameters.reducedSize) {
+                sdp += 'a=rtcp-rsize\r\n';
+            }
+        });
+
+        var desc = new window.RTCSessionDescription({
+            type: 'answer',
+            sdp: sdp
+        });
+        return Promise.resolve(desc);
+    };
+
+    RTCPeerConnection.prototype.addIceCandidate = function(candidate) {
+        var pc = this;
+        var sections;
+        if (candidate && !(candidate.sdpMLineIndex !== undefined ||
+            candidate.sdpMid)) {
+            return Promise.reject(new TypeError('sdpMLineIndex or sdpMid required'));
+        }
+
+        // TODO: needs to go into ops queue.
+        return new Promise(function(resolve, reject) {
+            if (!pc.remoteDescription) {
+                return reject(makeError('InvalidStateError',
+                    'Can not add ICE candidate without a remote description'));
+            } else if (!candidate || candidate.candidate === '') {
+                for (var j = 0; j < pc.transceivers.length; j++) {
+                    if (pc.transceivers[j].rejected) {
+                        continue;
+                    }
+                    pc.transceivers[j].iceTransport.addRemoteCandidate({});
+                    sections = SDPUtils.getMediaSections(pc.remoteDescription.sdp);
+                    sections[j] += 'a=end-of-candidates\r\n';
+                    pc.remoteDescription.sdp =
+                        SDPUtils.getDescription(pc.remoteDescription.sdp) +
+                        sections.join('');
+                    if (pc.usingBundle) {
+                        break;
+                    }
+                }
+            } else {
+                var sdpMLineIndex = candidate.sdpMLineIndex;
+                if (candidate.sdpMid) {
+                    for (var i = 0; i < pc.transceivers.length; i++) {
+                        if (pc.transceivers[i].mid === candidate.sdpMid) {
+                            sdpMLineIndex = i;
+                            break;
+                        }
+                    }
+                }
+                var transceiver = pc.transceivers[sdpMLineIndex];
+                if (transceiver) {
+                    if (transceiver.rejected) {
+                        return resolve();
+                    }
+                    var cand = Object.keys(candidate.candidate).length > 0 ?
+                        SDPUtils.parseCandidate(candidate.candidate) : {};
+                    // Ignore Chrome's invalid candidates since Edge does not like them.
+                    if (cand.protocol === 'tcp' && (cand.port === 0 || cand.port === 9)) {
+                        return resolve();
+                    }
+                    // Ignore RTCP candidates, we assume RTCP-MUX.
+                    if (cand.component && cand.component !== 1) {
+                        return resolve();
+                    }
+                    // when using bundle, avoid adding candidates to the wrong
+                    // ice transport. And avoid adding candidates added in the SDP.
+                    if (sdpMLineIndex === 0 || (sdpMLineIndex > 0 &&
+                        transceiver.iceTransport !== pc.transceivers[0].iceTransport)) {
+                        if (!maybeAddCandidate(transceiver.iceTransport, cand)) {
+                            return reject(makeError('OperationError',
+                                'Can not add ICE candidate'));
+                        }
+                    }
+
+                    // update the remoteDescription.
+                    var candidateString = candidate.candidate.trim();
+                    if (candidateString.indexOf('a=') === 0) {
+                        candidateString = candidateString.substr(2);
+                    }
+                    sections = SDPUtils.getMediaSections(pc.remoteDescription.sdp);
+                    sections[sdpMLineIndex] += 'a=' +
+                        (cand.type ? candidateString : 'end-of-candidates')
+                        + '\r\n';
+                    pc.remoteDescription.sdp =
+                        SDPUtils.getDescription(pc.remoteDescription.sdp) +
+                        sections.join('');
+                } else {
+                    return reject(makeError('OperationError',
+                        'Can not add ICE candidate'));
+                }
+            }
+            resolve();
+        });
+    };
+
+    RTCPeerConnection.prototype.getStats = function() {
+        var promises = [];
+        this.transceivers.forEach(function(transceiver) {
+            ['rtpSender', 'rtpReceiver', 'iceGatherer', 'iceTransport',
+                'dtlsTransport'].forEach(function(method) {
+                if (transceiver[method]) {
+                    promises.push(transceiver[method].getStats());
+                }
+            });
+        });
+        var fixStatsType = function(stat) {
+            return {
+                inboundrtp: 'inbound-rtp',
+                outboundrtp: 'outbound-rtp',
+                candidatepair: 'candidate-pair',
+                localcandidate: 'local-candidate',
+                remotecandidate: 'remote-candidate'
+            }[stat.type] || stat.type;
+        };
+        return new Promise(function(resolve) {
+            // shim getStats with maplike support
+            var results = new Map();
+            Promise.all(promises).then(function(res) {
+                res.forEach(function(result) {
+                    Object.keys(result).forEach(function(id) {
+                        result[id].type = fixStatsType(result[id]);
+                        results.set(id, result[id]);
+                    });
+                });
+                resolve(results);
+            });
+        });
+    };
+
+    // legacy callback shims. Should be moved to adapter.js some days.
+    var methods = ['createOffer', 'createAnswer'];
+    methods.forEach(function(method) {
+        var nativeMethod = RTCPeerConnection.prototype[method];
+        RTCPeerConnection.prototype[method] = function() {
+            var args = arguments;
+            if (typeof args[0] === 'function' ||
+                typeof args[1] === 'function') { // legacy
+                return nativeMethod.apply(this, [arguments[2]])
+                    .then(function(description) {
+                        if (typeof args[0] === 'function') {
+                            args[0].apply(null, [description]);
+                        }
+                    }, function(error) {
+                        if (typeof args[1] === 'function') {
+                            args[1].apply(null, [error]);
+                        }
+                    });
+            }
+            return nativeMethod.apply(this, arguments);
+        };
+    });
+
+    methods = ['setLocalDescription', 'setRemoteDescription', 'addIceCandidate'];
+    methods.forEach(function(method) {
+        var nativeMethod = RTCPeerConnection.prototype[method];
+        RTCPeerConnection.prototype[method] = function() {
+            var args = arguments;
+            if (typeof args[1] === 'function' ||
+                typeof args[2] === 'function') { // legacy
+                return nativeMethod.apply(this, arguments)
+                    .then(function() {
+                        if (typeof args[1] === 'function') {
+                            args[1].apply(null);
+                        }
+                    }, function(error) {
+                        if (typeof args[2] === 'function') {
+                            args[2].apply(null, [error]);
+                        }
+                    });
+            }
+            return nativeMethod.apply(this, arguments);
+        };
+    });
+
+    // getStats is special. It doesn't have a spec legacy method yet we support
+    // getStats(something, cb) without error callbacks.
+    ['getStats'].forEach(function(method) {
+        var nativeMethod = RTCPeerConnection.prototype[method];
+        RTCPeerConnection.prototype[method] = function() {
+            var args = arguments;
+            if (typeof args[1] === 'function') {
+                return nativeMethod.apply(this, arguments)
+                    .then(function() {
+                        if (typeof args[1] === 'function') {
+                            args[1].apply(null);
+                        }
+                    });
+            }
+            return nativeMethod.apply(this, arguments);
+        };
+    });
+
+    return RTCPeerConnection;
+};
+
+},{"sdp":2}],2:[function(require,module,exports){
+/* eslint-env node */
+'use strict';
+
+// SDP helpers.
+var SDPUtils = {};
+
+// Generate an alphanumeric identifier for cname or mids.
+// TODO: use UUIDs instead? https://gist.github.com/jed/982883
+SDPUtils.generateIdentifier = function() {
+    return Math.random().toString(36).substr(2, 10);
+};
+
+// The RTCP CNAME used by all peerconnections from the same JS.
+SDPUtils.localCName = SDPUtils.generateIdentifier();
+
+// Splits SDP into lines, dealing with both CRLF and LF.
+SDPUtils.splitLines = function(blob) {
+    return blob.trim().split('\n').map(function(line) {
+        return line.trim();
+    });
+};
+// Splits SDP into sessionpart and mediasections. Ensures CRLF.
+SDPUtils.splitSections = function(blob) {
+    var parts = blob.split('\nm=');
+    return parts.map(function(part, index) {
+        return (index > 0 ? 'm=' + part : part).trim() + '\r\n';
+    });
+};
+
+// returns the session description.
+SDPUtils.getDescription = function(blob) {
+    var sections = SDPUtils.splitSections(blob);
+    return sections && sections[0];
+};
+
+// returns the individual media sections.
+SDPUtils.getMediaSections = function(blob) {
+    var sections = SDPUtils.splitSections(blob);
+    sections.shift();
+    return sections;
+};
+
+// Returns lines that start with a certain prefix.
+SDPUtils.matchPrefix = function(blob, prefix) {
+    return SDPUtils.splitLines(blob).filter(function(line) {
+        return line.indexOf(prefix) === 0;
+    });
+};
+
+// Parses an ICE candidate line. Sample input:
+// candidate:702786350 2 udp 41819902 8.8.8.8 60769 typ relay raddr 8.8.8.8
+// rport 55996"
+SDPUtils.parseCandidate = function(line) {
+    var parts;
+    // Parse both variants.
+    if (line.indexOf('a=candidate:') === 0) {
+        parts = line.substring(12).split(' ');
+    } else {
+        parts = line.substring(10).split(' ');
+    }
+
+    var candidate = {
+        foundation: parts[0],
+        component: parseInt(parts[1], 10),
+        protocol: parts[2].toLowerCase(),
+        priority: parseInt(parts[3], 10),
+        ip: parts[4],
+        port: parseInt(parts[5], 10),
+        // skip parts[6] == 'typ'
+        type: parts[7]
+    };
+
+    for (var i = 8; i < parts.length; i += 2) {
+        switch (parts[i]) {
+            case 'raddr':
+                candidate.relatedAddress = parts[i + 1];
+                break;
+            case 'rport':
+                candidate.relatedPort = parseInt(parts[i + 1], 10);
+                break;
+            case 'tcptype':
+                candidate.tcpType = parts[i + 1];
+                break;
+            case 'ufrag':
+                candidate.ufrag = parts[i + 1]; // for backward compability.
+                candidate.usernameFragment = parts[i + 1];
+                break;
+            default: // extension handling, in particular ufrag
+                candidate[parts[i]] = parts[i + 1];
+                break;
+        }
+    }
+    return candidate;
+};
+
+// Translates a candidate object into SDP candidate attribute.
+SDPUtils.writeCandidate = function(candidate) {
+    var sdp = [];
+    sdp.push(candidate.foundation);
+    sdp.push(candidate.component);
+    sdp.push(candidate.protocol.toUpperCase());
+    sdp.push(candidate.priority);
+    sdp.push(candidate.ip);
+    sdp.push(candidate.port);
+
+    var type = candidate.type;
+    sdp.push('typ');
+    sdp.push(type);
+    if (type !== 'host' && candidate.relatedAddress &&
+        candidate.relatedPort) {
+        sdp.push('raddr');
+        sdp.push(candidate.relatedAddress); // was: relAddr
+        sdp.push('rport');
+        sdp.push(candidate.relatedPort); // was: relPort
+    }
+    if (candidate.tcpType && candidate.protocol.toLowerCase() === 'tcp') {
+        sdp.push('tcptype');
+        sdp.push(candidate.tcpType);
+    }
+    if (candidate.usernameFragment || candidate.ufrag) {
+        sdp.push('ufrag');
+        sdp.push(candidate.usernameFragment || candidate.ufrag);
+    }
+    return 'candidate:' + sdp.join(' ');
+};
+
+// Parses an ice-options line, returns an array of option tags.
+// a=ice-options:foo bar
+SDPUtils.parseIceOptions = function(line) {
+    return line.substr(14).split(' ');
+}
+
+// Parses an rtpmap line, returns RTCRtpCoddecParameters. Sample input:
+// a=rtpmap:111 opus/48000/2
+SDPUtils.parseRtpMap = function(line) {
+    var parts = line.substr(9).split(' ');
+    var parsed = {
+        payloadType: parseInt(parts.shift(), 10) // was: id
+    };
+
+    parts = parts[0].split('/');
+
+    parsed.name = parts[0];
+    parsed.clockRate = parseInt(parts[1], 10); // was: clockrate
+    // was: channels
+    parsed.numChannels = parts.length === 3 ? parseInt(parts[2], 10) : 1;
+    return parsed;
+};
+
+// Generate an a=rtpmap line from RTCRtpCodecCapability or
+// RTCRtpCodecParameters.
+SDPUtils.writeRtpMap = function(codec) {
+    var pt = codec.payloadType;
+    if (codec.preferredPayloadType !== undefined) {
+        pt = codec.preferredPayloadType;
+    }
+    return 'a=rtpmap:' + pt + ' ' + codec.name + '/' + codec.clockRate +
+        (codec.numChannels !== 1 ? '/' + codec.numChannels : '') + '\r\n';
+};
+
+// Parses an a=extmap line (headerextension from RFC 5285). Sample input:
+// a=extmap:2 urn:ietf:params:rtp-hdrext:toffset
+// a=extmap:2/sendonly urn:ietf:params:rtp-hdrext:toffset
+SDPUtils.parseExtmap = function(line) {
+    var parts = line.substr(9).split(' ');
+    return {
+        id: parseInt(parts[0], 10),
+        direction: parts[0].indexOf('/') > 0 ? parts[0].split('/')[1] : 'sendrecv',
+        uri: parts[1]
+    };
+};
+
+// Generates a=extmap line from RTCRtpHeaderExtensionParameters or
+// RTCRtpHeaderExtension.
+SDPUtils.writeExtmap = function(headerExtension) {
+    return 'a=extmap:' + (headerExtension.id || headerExtension.preferredId) +
+        (headerExtension.direction && headerExtension.direction !== 'sendrecv'
+            ? '/' + headerExtension.direction
+            : '') +
+        ' ' + headerExtension.uri + '\r\n';
+};
+
+// Parses an ftmp line, returns dictionary. Sample input:
+// a=fmtp:96 vbr=on;cng=on
+// Also deals with vbr=on; cng=on
+SDPUtils.parseFmtp = function(line) {
+    var parsed = {};
+    var kv;
+    var parts = line.substr(line.indexOf(' ') + 1).split(';');
+    for (var j = 0; j < parts.length; j++) {
+        kv = parts[j].trim().split('=');
+        parsed[kv[0].trim()] = kv[1];
+    }
+    return parsed;
+};
+
+// Generates an a=ftmp line from RTCRtpCodecCapability or RTCRtpCodecParameters.
+SDPUtils.writeFmtp = function(codec) {
+    var line = '';
+    var pt = codec.payloadType;
+    if (codec.preferredPayloadType !== undefined) {
+        pt = codec.preferredPayloadType;
+    }
+    if (codec.parameters && Object.keys(codec.parameters).length) {
+        var params = [];
+        Object.keys(codec.parameters).forEach(function(param) {
+            params.push(param + '=' + codec.parameters[param]);
+        });
+        line += 'a=fmtp:' + pt + ' ' + params.join(';') + '\r\n';
+    }
+    return line;
+};
+
+// Parses an rtcp-fb line, returns RTCPRtcpFeedback object. Sample input:
+// a=rtcp-fb:98 nack rpsi
+SDPUtils.parseRtcpFb = function(line) {
+    var parts = line.substr(line.indexOf(' ') + 1).split(' ');
+    return {
+        type: parts.shift(),
+        parameter: parts.join(' ')
+    };
+};
+// Generate a=rtcp-fb lines from RTCRtpCodecCapability or RTCRtpCodecParameters.
+SDPUtils.writeRtcpFb = function(codec) {
+    var lines = '';
+    var pt = codec.payloadType;
+    if (codec.preferredPayloadType !== undefined) {
+        pt = codec.preferredPayloadType;
+    }
+    if (codec.rtcpFeedback && codec.rtcpFeedback.length) {
+        // FIXME: special handling for trr-int?
+        codec.rtcpFeedback.forEach(function(fb) {
+            lines += 'a=rtcp-fb:' + pt + ' ' + fb.type +
+                (fb.parameter && fb.parameter.length ? ' ' + fb.parameter : '') +
+                '\r\n';
+        });
+    }
+    return lines;
+};
+
+// Parses an RFC 5576 ssrc media attribute. Sample input:
+// a=ssrc:3735928559 cname:something
+SDPUtils.parseSsrcMedia = function(line) {
+    var sp = line.indexOf(' ');
+    var parts = {
+        ssrc: parseInt(line.substr(7, sp - 7), 10)
+    };
+    var colon = line.indexOf(':', sp);
+    if (colon > -1) {
+        parts.attribute = line.substr(sp + 1, colon - sp - 1);
+        parts.value = line.substr(colon + 1);
+    } else {
+        parts.attribute = line.substr(sp + 1);
+    }
+    return parts;
+};
+
+// Extracts the MID (RFC 5888) from a media section.
+// returns the MID or undefined if no mid line was found.
+SDPUtils.getMid = function(mediaSection) {
+    var mid = SDPUtils.matchPrefix(mediaSection, 'a=mid:')[0];
+    if (mid) {
+        return mid.substr(6);
+    }
+}
+
+SDPUtils.parseFingerprint = function(line) {
+    var parts = line.substr(14).split(' ');
+    return {
+        algorithm: parts[0].toLowerCase(), // algorithm is case-sensitive in Edge.
+        value: parts[1]
+    };
+};
+
+// Extracts DTLS parameters from SDP media section or sessionpart.
+// FIXME: for consistency with other functions this should only
+//   get the fingerprint line as input. See also getIceParameters.
+SDPUtils.getDtlsParameters = function(mediaSection, sessionpart) {
+    var lines = SDPUtils.matchPrefix(mediaSection + sessionpart,
+        'a=fingerprint:');
+    // Note: a=setup line is ignored since we use the 'auto' role.
+    // Note2: 'algorithm' is not case sensitive except in Edge.
+    return {
+        role: 'auto',
+        fingerprints: lines.map(SDPUtils.parseFingerprint)
+    };
+};
+
+// Serializes DTLS parameters to SDP.
+SDPUtils.writeDtlsParameters = function(params, setupType) {
+    var sdp = 'a=setup:' + setupType + '\r\n';
+    params.fingerprints.forEach(function(fp) {
+        sdp += 'a=fingerprint:' + fp.algorithm + ' ' + fp.value + '\r\n';
+    });
+    return sdp;
+};
+// Parses ICE information from SDP media section or sessionpart.
+// FIXME: for consistency with other functions this should only
+//   get the ice-ufrag and ice-pwd lines as input.
+SDPUtils.getIceParameters = function(mediaSection, sessionpart) {
+    var lines = SDPUtils.splitLines(mediaSection);
+    // Search in session part, too.
+    lines = lines.concat(SDPUtils.splitLines(sessionpart));
+    var iceParameters = {
+        usernameFragment: lines.filter(function(line) {
+            return line.indexOf('a=ice-ufrag:') === 0;
+        })[0].substr(12),
+        password: lines.filter(function(line) {
+            return line.indexOf('a=ice-pwd:') === 0;
+        })[0].substr(10)
+    };
+    return iceParameters;
+};
+
+// Serializes ICE parameters to SDP.
+SDPUtils.writeIceParameters = function(params) {
+    return 'a=ice-ufrag:' + params.usernameFragment + '\r\n' +
+        'a=ice-pwd:' + params.password + '\r\n';
+};
+
+// Parses the SDP media section and returns RTCRtpParameters.
+SDPUtils.parseRtpParameters = function(mediaSection) {
+    var description = {
+        codecs: [],
+        headerExtensions: [],
+        fecMechanisms: [],
+        rtcp: []
+    };
+    var lines = SDPUtils.splitLines(mediaSection);
+    var mline = lines[0].split(' ');
+    for (var i = 3; i < mline.length; i++) { // find all codecs from mline[3..]
+        var pt = mline[i];
+        var rtpmapline = SDPUtils.matchPrefix(
+            mediaSection, 'a=rtpmap:' + pt + ' ')[0];
+        if (rtpmapline) {
+            var codec = SDPUtils.parseRtpMap(rtpmapline);
+            var fmtps = SDPUtils.matchPrefix(
+                mediaSection, 'a=fmtp:' + pt + ' ');
+            // Only the first a=fmtp:<pt> is considered.
+            codec.parameters = fmtps.length ? SDPUtils.parseFmtp(fmtps[0]) : {};
+            codec.rtcpFeedback = SDPUtils.matchPrefix(
+                mediaSection, 'a=rtcp-fb:' + pt + ' ')
+                .map(SDPUtils.parseRtcpFb);
+            description.codecs.push(codec);
+            // parse FEC mechanisms from rtpmap lines.
+            switch (codec.name.toUpperCase()) {
+                case 'RED':
+                case 'ULPFEC':
+                    description.fecMechanisms.push(codec.name.toUpperCase());
+                    break;
+                default: // only RED and ULPFEC are recognized as FEC mechanisms.
+                    break;
+            }
+        }
+    }
+    SDPUtils.matchPrefix(mediaSection, 'a=extmap:').forEach(function(line) {
+        description.headerExtensions.push(SDPUtils.parseExtmap(line));
+    });
+    // FIXME: parse rtcp.
+    return description;
+};
+
+// Generates parts of the SDP media section describing the capabilities /
+// parameters.
+SDPUtils.writeRtpDescription = function(kind, caps) {
+    var sdp = '';
+
+    // Build the mline.
+    sdp += 'm=' + kind + ' ';
+    sdp += caps.codecs.length > 0 ? '9' : '0'; // reject if no codecs.
+    sdp += ' UDP/TLS/RTP/SAVPF ';
+    sdp += caps.codecs.map(function(codec) {
+        if (codec.preferredPayloadType !== undefined) {
+            return codec.preferredPayloadType;
+        }
+        return codec.payloadType;
+    }).join(' ') + '\r\n';
+
+    sdp += 'c=IN IP4 0.0.0.0\r\n';
+    sdp += 'a=rtcp:9 IN IP4 0.0.0.0\r\n';
+
+    // Add a=rtpmap lines for each codec. Also fmtp and rtcp-fb.
+    caps.codecs.forEach(function(codec) {
+        sdp += SDPUtils.writeRtpMap(codec);
+        sdp += SDPUtils.writeFmtp(codec);
+        sdp += SDPUtils.writeRtcpFb(codec);
+    });
+    var maxptime = 0;
+    caps.codecs.forEach(function(codec) {
+        if (codec.maxptime > maxptime) {
+            maxptime = codec.maxptime;
+        }
+    });
+    if (maxptime > 0) {
+        sdp += 'a=maxptime:' + maxptime + '\r\n';
+    }
+    sdp += 'a=rtcp-mux\r\n';
+
+    caps.headerExtensions.forEach(function(extension) {
+        sdp += SDPUtils.writeExtmap(extension);
+    });
+    // FIXME: write fecMechanisms.
+    return sdp;
+};
+
+// Parses the SDP media section and returns an array of
+// RTCRtpEncodingParameters.
+SDPUtils.parseRtpEncodingParameters = function(mediaSection) {
+    var encodingParameters = [];
+    var description = SDPUtils.parseRtpParameters(mediaSection);
+    var hasRed = description.fecMechanisms.indexOf('RED') !== -1;
+    var hasUlpfec = description.fecMechanisms.indexOf('ULPFEC') !== -1;
+
+    // filter a=ssrc:... cname:, ignore PlanB-msid
+    var ssrcs = SDPUtils.matchPrefix(mediaSection, 'a=ssrc:')
+        .map(function(line) {
+            return SDPUtils.parseSsrcMedia(line);
+        })
+        .filter(function(parts) {
+            return parts.attribute === 'cname';
+        });
+    var primarySsrc = ssrcs.length > 0 && ssrcs[0].ssrc;
+    var secondarySsrc;
+
+    var flows = SDPUtils.matchPrefix(mediaSection, 'a=ssrc-group:FID')
+        .map(function(line) {
+            var parts = line.split(' ');
+            parts.shift();
+            return parts.map(function(part) {
+                return parseInt(part, 10);
+            });
+        });
+    if (flows.length > 0 && flows[0].length > 1 && flows[0][0] === primarySsrc) {
+        secondarySsrc = flows[0][1];
+    }
+
+    description.codecs.forEach(function(codec) {
+        if (codec.name.toUpperCase() === 'RTX' && codec.parameters.apt) {
+            var encParam = {
+                ssrc: primarySsrc,
+                codecPayloadType: parseInt(codec.parameters.apt, 10),
+                rtx: {
+                    ssrc: secondarySsrc
+                }
+            };
+            encodingParameters.push(encParam);
+            if (hasRed) {
+                encParam = JSON.parse(JSON.stringify(encParam));
+                encParam.fec = {
+                    ssrc: secondarySsrc,
+                    mechanism: hasUlpfec ? 'red+ulpfec' : 'red'
+                };
+                encodingParameters.push(encParam);
+            }
+        }
+    });
+    if (encodingParameters.length === 0 && primarySsrc) {
+        encodingParameters.push({
+            ssrc: primarySsrc
+        });
+    }
+
+    // we support both b=AS and b=TIAS but interpret AS as TIAS.
+    var bandwidth = SDPUtils.matchPrefix(mediaSection, 'b=');
+    if (bandwidth.length) {
+        if (bandwidth[0].indexOf('b=TIAS:') === 0) {
+            bandwidth = parseInt(bandwidth[0].substr(7), 10);
+        } else if (bandwidth[0].indexOf('b=AS:') === 0) {
+            // use formula from JSEP to convert b=AS to TIAS value.
+            bandwidth = parseInt(bandwidth[0].substr(5), 10) * 1000 * 0.95
+                - (50 * 40 * 8);
+        } else {
+            bandwidth = undefined;
+        }
+        encodingParameters.forEach(function(params) {
+            params.maxBitrate = bandwidth;
+        });
+    }
+    return encodingParameters;
+};
+
+// parses http://draft.ortc.org/#rtcrtcpparameters*
+SDPUtils.parseRtcpParameters = function(mediaSection) {
+    var rtcpParameters = {};
+
+    var cname;
+    // Gets the first SSRC. Note that with RTX there might be multiple
+    // SSRCs.
+    var remoteSsrc = SDPUtils.matchPrefix(mediaSection, 'a=ssrc:')
+        .map(function(line) {
+            return SDPUtils.parseSsrcMedia(line);
+        })
+        .filter(function(obj) {
+            return obj.attribute === 'cname';
+        })[0];
+    if (remoteSsrc) {
+        rtcpParameters.cname = remoteSsrc.value;
+        rtcpParameters.ssrc = remoteSsrc.ssrc;
+    }
+
+    // Edge uses the compound attribute instead of reducedSize
+    // compound is !reducedSize
+    var rsize = SDPUtils.matchPrefix(mediaSection, 'a=rtcp-rsize');
+    rtcpParameters.reducedSize = rsize.length > 0;
+    rtcpParameters.compound = rsize.length === 0;
+
+    // parses the rtcp-mux attrÑ–bute.
+    // Note that Edge does not support unmuxed RTCP.
+    var mux = SDPUtils.matchPrefix(mediaSection, 'a=rtcp-mux');
+    rtcpParameters.mux = mux.length > 0;
+
+    return rtcpParameters;
+};
+
+// parses either a=msid: or a=ssrc:... msid lines and returns
+// the id of the MediaStream and MediaStreamTrack.
+SDPUtils.parseMsid = function(mediaSection) {
+    var parts;
+    var spec = SDPUtils.matchPrefix(mediaSection, 'a=msid:');
+    if (spec.length === 1) {
+        parts = spec[0].substr(7).split(' ');
+        return {stream: parts[0], track: parts[1]};
+    }
+    var planB = SDPUtils.matchPrefix(mediaSection, 'a=ssrc:')
+        .map(function(line) {
+            return SDPUtils.parseSsrcMedia(line);
+        })
+        .filter(function(parts) {
+            return parts.attribute === 'msid';
+        });
+    if (planB.length > 0) {
+        parts = planB[0].value.split(' ');
+        return {stream: parts[0], track: parts[1]};
+    }
+};
+
+// Generate a session ID for SDP.
+// https://tools.ietf.org/html/draft-ietf-rtcweb-jsep-20#section-5.2.1
+// recommends using a cryptographically random +ve 64-bit value
+// but right now this should be acceptable and within the right range
+SDPUtils.generateSessionId = function() {
+    return Math.random().toString().substr(2, 21);
+};
+
+// Write boilder plate for start of SDP
+// sessId argument is optional - if not supplied it will
+// be generated randomly
+// sessVersion is optional and defaults to 2
+SDPUtils.writeSessionBoilerplate = function(sessId, sessVer) {
+    var sessionId;
+    var version = sessVer !== undefined ? sessVer : 2;
+    if (sessId) {
+        sessionId = sessId;
+    } else {
+        sessionId = SDPUtils.generateSessionId();
+    }
+    // FIXME: sess-id should be an NTP timestamp.
+    return 'v=0\r\n' +
+        'o=thisisadapterortc ' + sessionId + ' ' + version + ' IN IP4 127.0.0.1\r\n' +
+        's=-\r\n' +
+        't=0 0\r\n';
+};
+
+SDPUtils.writeMediaSection = function(transceiver, caps, type, stream) {
+    var sdp = SDPUtils.writeRtpDescription(transceiver.kind, caps);
+
+    // Map ICE parameters (ufrag, pwd) to SDP.
+    sdp += SDPUtils.writeIceParameters(
+        transceiver.iceGatherer.getLocalParameters());
+
+    // Map DTLS parameters to SDP.
+    sdp += SDPUtils.writeDtlsParameters(
+        transceiver.dtlsTransport.getLocalParameters(),
+        type === 'offer' ? 'actpass' : 'active');
+
+    sdp += 'a=mid:' + transceiver.mid + '\r\n';
+
+    if (transceiver.direction) {
+        sdp += 'a=' + transceiver.direction + '\r\n';
+    } else if (transceiver.rtpSender && transceiver.rtpReceiver) {
+        sdp += 'a=sendrecv\r\n';
+    } else if (transceiver.rtpSender) {
+        sdp += 'a=sendonly\r\n';
+    } else if (transceiver.rtpReceiver) {
+        sdp += 'a=recvonly\r\n';
+    } else {
+        sdp += 'a=inactive\r\n';
+    }
+
+    if (transceiver.rtpSender) {
+        // spec.
+        var msid = 'msid:' + stream.id + ' ' +
+            transceiver.rtpSender.track.id + '\r\n';
+        sdp += 'a=' + msid;
+
+        // for Chrome.
+        sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].ssrc +
+            ' ' + msid;
+        if (transceiver.sendEncodingParameters[0].rtx) {
+            sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].rtx.ssrc +
+                ' ' + msid;
+            sdp += 'a=ssrc-group:FID ' +
+                transceiver.sendEncodingParameters[0].ssrc + ' ' +
+                transceiver.sendEncodingParameters[0].rtx.ssrc +
+                '\r\n';
+        }
+    }
+    // FIXME: this should be written by writeRtpDescription.
+    sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].ssrc +
+        ' cname:' + SDPUtils.localCName + '\r\n';
+    if (transceiver.rtpSender && transceiver.sendEncodingParameters[0].rtx) {
+        sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].rtx.ssrc +
+            ' cname:' + SDPUtils.localCName + '\r\n';
+    }
+    return sdp;
+};
+
+// Gets the direction from the mediaSection or the sessionpart.
+SDPUtils.getDirection = function(mediaSection, sessionpart) {
+    // Look for sendrecv, sendonly, recvonly, inactive, default to sendrecv.
+    var lines = SDPUtils.splitLines(mediaSection);
+    for (var i = 0; i < lines.length; i++) {
+        switch (lines[i]) {
+            case 'a=sendrecv':
+            case 'a=sendonly':
+            case 'a=recvonly':
+            case 'a=inactive':
+                return lines[i].substr(2);
+            default:
+            // FIXME: What should happen here?
+        }
+    }
+    if (sessionpart) {
+        return SDPUtils.getDirection(sessionpart);
+    }
+    return 'sendrecv';
+};
+
+SDPUtils.getKind = function(mediaSection) {
+    var lines = SDPUtils.splitLines(mediaSection);
+    var mline = lines[0].split(' ');
+    return mline[0].substr(2);
+};
+
+SDPUtils.isRejected = function(mediaSection) {
+    return mediaSection.split(' ', 2)[1] === '0';
+};
+
+SDPUtils.parseMLine = function(mediaSection) {
+    var lines = SDPUtils.splitLines(mediaSection);
+    var parts = lines[0].substr(2).split(' ');
+    return {
+        kind: parts[0],
+        port: parseInt(parts[1], 10),
+        protocol: parts[2],
+        fmt: parts.slice(3).join(' ')
+    };
+};
+
+SDPUtils.parseOLine = function(mediaSection) {
+    var line = SDPUtils.matchPrefix(mediaSection, 'o=')[0];
+    var parts = line.substr(2).split(' ');
+    return {
+        username: parts[0],
+        sessionId: parts[1],
+        sessionVersion: parseInt(parts[2], 10),
+        netType: parts[3],
+        addressType: parts[4],
+        address: parts[5],
+    };
+}
+
+// Expose public methods.
+if (typeof module === 'object') {
+    module.exports = SDPUtils;
+}
+
+},{}],3:[function(require,module,exports){
+(function (global){
+    /*
+*  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+*
+*  Use of this source code is governed by a BSD-style license
+*  that can be found in the LICENSE file in the root of the source
+*  tree.
+*/
+    /* eslint-env node */
+
+    'use strict';
+
+    var adapterFactory = require('./adapter_factory.js');
+    module.exports = adapterFactory({window: global.window});
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./adapter_factory.js":4}],4:[function(require,module,exports){
+/*
+*  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+*
+*  Use of this source code is governed by a BSD-style license
+*  that can be found in the LICENSE file in the root of the source
+*  tree.
+*/
+/* eslint-env node */
+
+'use strict';
+
+var utils = require('./utils');
+// Shimming starts here.
+module.exports = function(dependencies, opts) {
+    var window = dependencies && dependencies.window;
+
+    var options = {
+        shimChrome: true,
+        shimFirefox: true,
+        shimEdge: true,
+        shimSafari: true,
+    };
+
+    for (var key in opts) {
+        if (hasOwnProperty.call(opts, key)) {
+            options[key] = opts[key];
+        }
+    }
+
+    // Utils.
+    var logging = utils.log;
+    var browserDetails = utils.detectBrowser(window);
+
+    // Uncomment the line below if you want logging to occur, including logging
+    // for the switch statement below. Can also be turned on in the browser via
+    // adapter.disableLog(false), but then logging from the switch statement below
+    // will not appear.
+    // require('./utils').disableLog(false);
+
+    // Browser shims.
+    var chromeShim = require('./chrome/chrome_shim') || null;
+    var edgeShim = require('./edge/edge_shim') || null;
+    var firefoxShim = require('./firefox/firefox_shim') || null;
+    var safariShim = require('./safari/safari_shim') || null;
+    var commonShim = require('./common_shim') || null;
+
+    // Export to the adapter global object visible in the browser.
+    var adapter = {
+        browserDetails: browserDetails,
+        commonShim: commonShim,
+        extractVersion: utils.extractVersion,
+        disableLog: utils.disableLog,
+        disableWarnings: utils.disableWarnings
+    };
+
+    // Shim browser if found.
+    switch (browserDetails.browser) {
+        case 'chrome':
+            if (!chromeShim || !chromeShim.shimPeerConnection ||
+                !options.shimChrome) {
+                logging('Chrome shim is not included in this adapter release.');
+                return adapter;
+            }
+            logging('adapter.js shimming chrome.');
+            // Export to the adapter global object visible in the browser.
+            adapter.browserShim = chromeShim;
+            commonShim.shimCreateObjectURL(window);
+
+            chromeShim.shimGetUserMedia(window);
+            chromeShim.shimMediaStream(window);
+            chromeShim.shimSourceObject(window);
+            chromeShim.shimPeerConnection(window);
+            chromeShim.shimOnTrack(window);
+            chromeShim.shimAddTrackRemoveTrack(window);
+            chromeShim.shimGetSendersWithDtmf(window);
+
+            commonShim.shimRTCIceCandidate(window);
+            commonShim.shimMaxMessageSize(window);
+            commonShim.shimSendThrowTypeError(window);
+            break;
+        case 'firefox':
+            if (!firefoxShim || !firefoxShim.shimPeerConnection ||
+                !options.shimFirefox) {
+                logging('Firefox shim is not included in this adapter release.');
+                return adapter;
+            }
+            logging('adapter.js shimming firefox.');
+            // Export to the adapter global object visible in the browser.
+            adapter.browserShim = firefoxShim;
+            commonShim.shimCreateObjectURL(window);
+
+            firefoxShim.shimGetUserMedia(window);
+            firefoxShim.shimSourceObject(window);
+            firefoxShim.shimPeerConnection(window);
+            firefoxShim.shimOnTrack(window);
+            firefoxShim.shimRemoveStream(window);
+
+            commonShim.shimRTCIceCandidate(window);
+            commonShim.shimMaxMessageSize(window);
+            commonShim.shimSendThrowTypeError(window);
+            break;
+        case 'edge':
+            if (!edgeShim || !edgeShim.shimPeerConnection || !options.shimEdge) {
+                logging('MS edge shim is not included in this adapter release.');
+                return adapter;
+            }
+            logging('adapter.js shimming edge.');
+            // Export to the adapter global object visible in the browser.
+            adapter.browserShim = edgeShim;
+            commonShim.shimCreateObjectURL(window);
+
+            edgeShim.shimGetUserMedia(window);
+            edgeShim.shimPeerConnection(window);
+            edgeShim.shimReplaceTrack(window);
+
+            // the edge shim implements the full RTCIceCandidate object.
+
+            commonShim.shimMaxMessageSize(window);
+            commonShim.shimSendThrowTypeError(window);
+            break;
+        case 'safari':
+            if (!safariShim || !options.shimSafari) {
+                logging('Safari shim is not included in this adapter release.');
+                return adapter;
+            }
+            logging('adapter.js shimming safari.');
+            // Export to the adapter global object visible in the browser.
+            adapter.browserShim = safariShim;
+            commonShim.shimCreateObjectURL(window);
+
+            safariShim.shimRTCIceServerUrls(window);
+            safariShim.shimCallbacksAPI(window);
+            safariShim.shimLocalStreamsAPI(window);
+            safariShim.shimRemoteStreamsAPI(window);
+            safariShim.shimTrackEventTransceiver(window);
+            safariShim.shimGetUserMedia(window);
+            safariShim.shimCreateOfferLegacy(window);
+
+            commonShim.shimRTCIceCandidate(window);
+            commonShim.shimMaxMessageSize(window);
+            commonShim.shimSendThrowTypeError(window);
+            break;
+        default:
+            logging('Unsupported browser!');
+            break;
+    }
+
+    return adapter;
+};
+
+},{"./chrome/chrome_shim":5,"./common_shim":7,"./edge/edge_shim":8,"./firefox/firefox_shim":10,"./safari/safari_shim":12,"./utils":13}],5:[function(require,module,exports){
+
+/*
+*  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+*
+*  Use of this source code is governed by a BSD-style license
+*  that can be found in the LICENSE file in the root of the source
+*  tree.
+*/
+/* eslint-env node */
+'use strict';
+var utils = require('../utils.js');
+var logging = utils.log;
+
+module.exports = {
+    shimGetUserMedia: require('./getusermedia'),
+    shimMediaStream: function(window) {
+        window.MediaStream = window.MediaStream || window.webkitMediaStream;
+    },
+
+    shimOnTrack: function(window) {
+        if (typeof window === 'object' && window.RTCPeerConnection && !('ontrack' in
+            window.RTCPeerConnection.prototype)) {
+            Object.defineProperty(window.RTCPeerConnection.prototype, 'ontrack', {
+                get: function() {
+                    return this._ontrack;
+                },
+                set: function(f) {
+                    if (this._ontrack) {
+                        this.removeEventListener('track', this._ontrack);
+                    }
+                    this.addEventListener('track', this._ontrack = f);
+                }
+            });
+            var origSetRemoteDescription =
+                window.RTCPeerConnection.prototype.setRemoteDescription;
+            window.RTCPeerConnection.prototype.setRemoteDescription = function() {
+                var pc = this;
+                if (!pc._ontrackpoly) {
+                    pc._ontrackpoly = function(e) {
+                        // onaddstream does not fire when a track is added to an existing
+                        // stream. But stream.onaddtrack is implemented so we use that.
+                        e.stream.addEventListener('addtrack', function(te) {
+                            var receiver;
+                            if (window.RTCPeerConnection.prototype.getReceivers) {
+                                receiver = pc.getReceivers().find(function(r) {
+                                    return r.track && r.track.id === te.track.id;
+                                });
+                            } else {
+                                receiver = {track: te.track};
+                            }
+
+                            var event = new Event('track');
+                            event.track = te.track;
+                            event.receiver = receiver;
+                            event.transceiver = {receiver: receiver};
+                            event.streams = [e.stream];
+                            pc.dispatchEvent(event);
+                        });
+                        e.stream.getTracks().forEach(function(track) {
+                            var receiver;
+                            if (window.RTCPeerConnection.prototype.getReceivers) {
+                                receiver = pc.getReceivers().find(function(r) {
+                                    return r.track && r.track.id === track.id;
+                                });
+                            } else {
+                                receiver = {track: track};
+                            }
+                            var event = new Event('track');
+                            event.track = track;
+                            event.receiver = receiver;
+                            event.transceiver = {receiver: receiver};
+                            event.streams = [e.stream];
+                            pc.dispatchEvent(event);
+                        });
+                    };
+                    pc.addEventListener('addstream', pc._ontrackpoly);
+                }
+                return origSetRemoteDescription.apply(pc, arguments);
+            };
+        } else if (!('RTCRtpTransceiver' in window)) {
+            utils.wrapPeerConnectionEvent(window, 'track', function(e) {
+                if (!e.transceiver) {
+                    e.transceiver = {receiver: e.receiver};
+                }
+                return e;
+            });
+        }
+    },
+
+    shimGetSendersWithDtmf: function(window) {
+        // Overrides addTrack/removeTrack, depends on shimAddTrackRemoveTrack.
+        if (typeof window === 'object' && window.RTCPeerConnection &&
+            !('getSenders' in window.RTCPeerConnection.prototype) &&
+            'createDTMFSender' in window.RTCPeerConnection.prototype) {
+            var shimSenderWithDtmf = function(pc, track) {
+                return {
+                    track: track,
+                    get dtmf() {
+                        if (this._dtmf === undefined) {
+                            if (track.kind === 'audio') {
+                                this._dtmf = pc.createDTMFSender(track);
+                            } else {
+                                this._dtmf = null;
+                            }
+                        }
+                        return this._dtmf;
+                    },
+                    _pc: pc
+                };
+            };
+
+            // augment addTrack when getSenders is not available.
+            if (!window.RTCPeerConnection.prototype.getSenders) {
+                window.RTCPeerConnection.prototype.getSenders = function() {
+                    this._senders = this._senders || [];
+                    return this._senders.slice(); // return a copy of the internal state.
+                };
+                var origAddTrack = window.RTCPeerConnection.prototype.addTrack;
+                window.RTCPeerConnection.prototype.addTrack = function(track, stream) {
+                    var pc = this;
+                    var sender = origAddTrack.apply(pc, arguments);
+                    if (!sender) {
+                        sender = shimSenderWithDtmf(pc, track);
+                        pc._senders.push(sender);
+                    }
+                    return sender;
+                };
+
+                var origRemoveTrack = window.RTCPeerConnection.prototype.removeTrack;
+                window.RTCPeerConnection.prototype.removeTrack = function(sender) {
+                    var pc = this;
+                    origRemoveTrack.apply(pc, arguments);
+                    var idx = pc._senders.indexOf(sender);
+                    if (idx !== -1) {
+                        pc._senders.splice(idx, 1);
+                    }
+                };
+            }
+            var origAddStream = window.RTCPeerConnection.prototype.addStream;
+            window.RTCPeerConnection.prototype.addStream = function(stream) {
+                var pc = this;
+                pc._senders = pc._senders || [];
+                origAddStream.apply(pc, [stream]);
+                stream.getTracks().forEach(function(track) {
+                    pc._senders.push(shimSenderWithDtmf(pc, track));
+                });
+            };
+
+            var origRemoveStream = window.RTCPeerConnection.prototype.removeStream;
+            window.RTCPeerConnection.prototype.removeStream = function(stream) {
+                var pc = this;
+                pc._senders = pc._senders || [];
+                origRemoveStream.apply(pc, [stream]);
+
+                stream.getTracks().forEach(function(track) {
+                    var sender = pc._senders.find(function(s) {
+                        return s.track === track;
+                    });
+                    if (sender) {
+                        pc._senders.splice(pc._senders.indexOf(sender), 1); // remove sender
+                    }
+                });
+            };
+        } else if (typeof window === 'object' && window.RTCPeerConnection &&
+            'getSenders' in window.RTCPeerConnection.prototype &&
+            'createDTMFSender' in window.RTCPeerConnection.prototype &&
+            window.RTCRtpSender &&
+            !('dtmf' in window.RTCRtpSender.prototype)) {
+            var origGetSenders = window.RTCPeerConnection.prototype.getSenders;
+            window.RTCPeerConnection.prototype.getSenders = function() {
+                var pc = this;
+                var senders = origGetSenders.apply(pc, []);
+                senders.forEach(function(sender) {
+                    sender._pc = pc;
+                });
+                return senders;
+            };
+
+            Object.defineProperty(window.RTCRtpSender.prototype, 'dtmf', {
+                get: function() {
+                    if (this._dtmf === undefined) {
+                        if (this.track.kind === 'audio') {
+                            this._dtmf = this._pc.createDTMFSender(this.track);
+                        } else {
+                            this._dtmf = null;
+                        }
+                    }
+                    return this._dtmf;
+                }
+            });
+        }
+    },
+
+    shimSourceObject: function(window) {
+        var URL = window && window.URL;
+
+        if (typeof window === 'object') {
+            if (window.HTMLMediaElement &&
+                !('srcObject' in window.HTMLMediaElement.prototype)) {
+                // Shim the srcObject property, once, when HTMLMediaElement is found.
+                Object.defineProperty(window.HTMLMediaElement.prototype, 'srcObject', {
+                    get: function() {
+                        return this._srcObject;
+                    },
+                    set: function(stream) {
+                        var self = this;
+                        // Use _srcObject as a private property for this shim
+                        this._srcObject = stream;
+                        if (this.src) {
+                            URL.revokeObjectURL(this.src);
+                        }
+
+                        if (!stream) {
+                            this.src = '';
+                            return undefined;
+                        }
+                        this.src = URL.createObjectURL(stream);
+                        // We need to recreate the blob url when a track is added or
+                        // removed. Doing it manually since we want to avoid a recursion.
+                        stream.addEventListener('addtrack', function() {
+                            if (self.src) {
+                                URL.revokeObjectURL(self.src);
+                            }
+                            self.src = URL.createObjectURL(stream);
+                        });
+                        stream.addEventListener('removetrack', function() {
+                            if (self.src) {
+                                URL.revokeObjectURL(self.src);
+                            }
+                            self.src = URL.createObjectURL(stream);
+                        });
+                    }
+                });
+            }
+        }
+    },
+
+    shimAddTrackRemoveTrackWithNative: function(window) {
+        // shim addTrack/removeTrack with native variants in order to make
+        // the interactions with legacy getLocalStreams behave as in other browsers.
+        // Keeps a mapping stream.id => [stream, rtpsenders...]
+        window.RTCPeerConnection.prototype.getLocalStreams = function() {
+            var pc = this;
+            this._shimmedLocalStreams = this._shimmedLocalStreams || {};
+            return Object.keys(this._shimmedLocalStreams).map(function(streamId) {
+                return pc._shimmedLocalStreams[streamId][0];
+            });
+        };
+
+        var origAddTrack = window.RTCPeerConnection.prototype.addTrack;
+        window.RTCPeerConnection.prototype.addTrack = function(track, stream) {
+            if (!stream) {
+                return origAddTrack.apply(this, arguments);
+            }
+            this._shimmedLocalStreams = this._shimmedLocalStreams || {};
+
+            var sender = origAddTrack.apply(this, arguments);
+            if (!this._shimmedLocalStreams[stream.id]) {
+                this._shimmedLocalStreams[stream.id] = [stream, sender];
+            } else if (this._shimmedLocalStreams[stream.id].indexOf(sender) === -1) {
+                this._shimmedLocalStreams[stream.id].push(sender);
+            }
+            return sender;
+        };
+
+        var origAddStream = window.RTCPeerConnection.prototype.addStream;
+        window.RTCPeerConnection.prototype.addStream = function(stream) {
+            var pc = this;
+            this._shimmedLocalStreams = this._shimmedLocalStreams || {};
+
+            stream.getTracks().forEach(function(track) {
+                var alreadyExists = pc.getSenders().find(function(s) {
+                    return s.track === track;
+                });
+                if (alreadyExists) {
+                    throw new DOMException('Track already exists.',
+                        'InvalidAccessError');
+                }
+            });
+            var existingSenders = pc.getSenders();
+            origAddStream.apply(this, arguments);
+            var newSenders = pc.getSenders().filter(function(newSender) {
+                return existingSenders.indexOf(newSender) === -1;
+            });
+            this._shimmedLocalStreams[stream.id] = [stream].concat(newSenders);
+        };
+
+        var origRemoveStream = window.RTCPeerConnection.prototype.removeStream;
+        window.RTCPeerConnection.prototype.removeStream = function(stream) {
+            this._shimmedLocalStreams = this._shimmedLocalStreams || {};
+            delete this._shimmedLocalStreams[stream.id];
+            return origRemoveStream.apply(this, arguments);
+        };
+
+        var origRemoveTrack = window.RTCPeerConnection.prototype.removeTrack;
+        window.RTCPeerConnection.prototype.removeTrack = function(sender) {
+            var pc = this;
+            this._shimmedLocalStreams = this._shimmedLocalStreams || {};
+            if (sender) {
+                Object.keys(this._shimmedLocalStreams).forEach(function(streamId) {
+                    var idx = pc._shimmedLocalStreams[streamId].indexOf(sender);
+                    if (idx !== -1) {
+                        pc._shimmedLocalStreams[streamId].splice(idx, 1);
+                    }
+                    if (pc._shimmedLocalStreams[streamId].length === 1) {
+                        delete pc._shimmedLocalStreams[streamId];
+                    }
+                });
+            }
+            return origRemoveTrack.apply(this, arguments);
+        };
+    },
+
+    shimAddTrackRemoveTrack: function(window) {
+        var browserDetails = utils.detectBrowser(window);
+        // shim addTrack and removeTrack.
+        if (window.RTCPeerConnection.prototype.addTrack &&
+            browserDetails.version >= 65) {
+            return this.shimAddTrackRemoveTrackWithNative(window);
+        }
+
+        // also shim pc.getLocalStreams when addTrack is shimmed
+        // to return the original streams.
+        var origGetLocalStreams = window.RTCPeerConnection.prototype
+            .getLocalStreams;
+        window.RTCPeerConnection.prototype.getLocalStreams = function() {
+            var pc = this;
+            var nativeStreams = origGetLocalStreams.apply(this);
+            pc._reverseStreams = pc._reverseStreams || {};
+            return nativeStreams.map(function(stream) {
+                return pc._reverseStreams[stream.id];
+            });
+        };
+
+        var origAddStream = window.RTCPeerConnection.prototype.addStream;
+        window.RTCPeerConnection.prototype.addStream = function(stream) {
+            var pc = this;
+            pc._streams = pc._streams || {};
+            pc._reverseStreams = pc._reverseStreams || {};
+
+            stream.getTracks().forEach(function(track) {
+                var alreadyExists = pc.getSenders().find(function(s) {
+                    return s.track === track;
+                });
+                if (alreadyExists) {
+                    throw new DOMException('Track already exists.',
+                        'InvalidAccessError');
+                }
+            });
+            // Add identity mapping for consistency with addTrack.
+            // Unless this is being used with a stream from addTrack.
+            if (!pc._reverseStreams[stream.id]) {
+                var newStream = new window.MediaStream(stream.getTracks());
+                pc._streams[stream.id] = newStream;
+                pc._reverseStreams[newStream.id] = stream;
+                stream = newStream;
+            }
+            origAddStream.apply(pc, [stream]);
+        };
+
+        var origRemoveStream = window.RTCPeerConnection.prototype.removeStream;
+        window.RTCPeerConnection.prototype.removeStream = function(stream) {
+            var pc = this;
+            pc._streams = pc._streams || {};
+            pc._reverseStreams = pc._reverseStreams || {};
+
+            origRemoveStream.apply(pc, [(pc._streams[stream.id] || stream)]);
+            delete pc._reverseStreams[(pc._streams[stream.id] ?
+                pc._streams[stream.id].id : stream.id)];
+            delete pc._streams[stream.id];
+        };
+
+        window.RTCPeerConnection.prototype.addTrack = function(track, stream) {
+            var pc = this;
+            if (pc.signalingState === 'closed') {
+                throw new DOMException(
+                    'The RTCPeerConnection\'s signalingState is \'closed\'.',
+                    'InvalidStateError');
+            }
+            var streams = [].slice.call(arguments, 1);
+            if (streams.length !== 1 ||
+                !streams[0].getTracks().find(function(t) {
+                    return t === track;
+                })) {
+                // this is not fully correct but all we can manage without
+                // [[associated MediaStreams]] internal slot.
+                throw new DOMException(
+                    'The adapter.js addTrack polyfill only supports a single ' +
+                    ' stream which is associated with the specified track.',
+                    'NotSupportedError');
+            }
+
+            var alreadyExists = pc.getSenders().find(function(s) {
+                return s.track === track;
+            });
+            if (alreadyExists) {
+                throw new DOMException('Track already exists.',
+                    'InvalidAccessError');
+            }
+
+            pc._streams = pc._streams || {};
+            pc._reverseStreams = pc._reverseStreams || {};
+            var oldStream = pc._streams[stream.id];
+            if (oldStream) {
+                // this is using odd Chrome behaviour, use with caution:
+                // https://bugs.chromium.org/p/webrtc/issues/detail?id=7815
+                // Note: we rely on the high-level addTrack/dtmf shim to
+                // create the sender with a dtmf sender.
+                oldStream.addTrack(track);
+
+                // Trigger ONN async.
+                Promise.resolve().then(function() {
+                    pc.dispatchEvent(new Event('negotiationneeded'));
+                });
+            } else {
+                var newStream = new window.MediaStream([track]);
+                pc._streams[stream.id] = newStream;
+                pc._reverseStreams[newStream.id] = stream;
+                pc.addStream(newStream);
+            }
+            return pc.getSenders().find(function(s) {
+                return s.track === track;
+            });
+        };
+
+        // replace the internal stream id with the external one and
+        // vice versa.
+        function replaceInternalStreamId(pc, description) {
+            var sdp = description.sdp;
+            Object.keys(pc._reverseStreams || []).forEach(function(internalId) {
+                var externalStream = pc._reverseStreams[internalId];
+                var internalStream = pc._streams[externalStream.id];
+                sdp = sdp.replace(new RegExp(internalStream.id, 'g'),
+                    externalStream.id);
+            });
+            return new RTCSessionDescription({
+                type: description.type,
+                sdp: sdp
+            });
+        }
+        function replaceExternalStreamId(pc, description) {
+            var sdp = description.sdp;
+            Object.keys(pc._reverseStreams || []).forEach(function(internalId) {
+                var externalStream = pc._reverseStreams[internalId];
+                var internalStream = pc._streams[externalStream.id];
+                sdp = sdp.replace(new RegExp(externalStream.id, 'g'),
+                    internalStream.id);
+            });
+            return new RTCSessionDescription({
+                type: description.type,
+                sdp: sdp
+            });
+        }
+        ['createOffer', 'createAnswer'].forEach(function(method) {
+            var nativeMethod = window.RTCPeerConnection.prototype[method];
+            window.RTCPeerConnection.prototype[method] = function() {
+                var pc = this;
+                var args = arguments;
+                var isLegacyCall = arguments.length &&
+                    typeof arguments[0] === 'function';
+                if (isLegacyCall) {
+                    return nativeMethod.apply(pc, [
+                        function(description) {
+                            var desc = replaceInternalStreamId(pc, description);
+                            args[0].apply(null, [desc]);
+                        },
+                        function(err) {
+                            if (args[1]) {
+                                args[1].apply(null, err);
+                            }
+                        }, arguments[2]
+                    ]);
+                }
+                return nativeMethod.apply(pc, arguments)
+                    .then(function(description) {
+                        return replaceInternalStreamId(pc, description);
+                    });
+            };
+        });
+
+        var origSetLocalDescription =
+            window.RTCPeerConnection.prototype.setLocalDescription;
+        window.RTCPeerConnection.prototype.setLocalDescription = function() {
+            var pc = this;
+            if (!arguments.length || !arguments[0].type) {
+                return origSetLocalDescription.apply(pc, arguments);
+            }
+            arguments[0] = replaceExternalStreamId(pc, arguments[0]);
+            return origSetLocalDescription.apply(pc, arguments);
+        };
+
+        // TODO: mangle getStats: https://w3c.github.io/webrtc-stats/#dom-rtcmediastreamstats-streamidentifier
+
+        var origLocalDescription = Object.getOwnPropertyDescriptor(
+            window.RTCPeerConnection.prototype, 'localDescription');
+        Object.defineProperty(window.RTCPeerConnection.prototype,
+            'localDescription', {
+                get: function() {
+                    var pc = this;
+                    var description = origLocalDescription.get.apply(this);
+                    if (description.type === '') {
+                        return description;
+                    }
+                    return replaceInternalStreamId(pc, description);
+                }
+            });
+
+        window.RTCPeerConnection.prototype.removeTrack = function(sender) {
+            var pc = this;
+            if (pc.signalingState === 'closed') {
+                throw new DOMException(
+                    'The RTCPeerConnection\'s signalingState is \'closed\'.',
+                    'InvalidStateError');
+            }
+            // We can not yet check for sender instanceof RTCRtpSender
+            // since we shim RTPSender. So we check if sender._pc is set.
+            if (!sender._pc) {
+                throw new DOMException('Argument 1 of RTCPeerConnection.removeTrack ' +
+                    'does not implement interface RTCRtpSender.', 'TypeError');
+            }
+            var isLocal = sender._pc === pc;
+            if (!isLocal) {
+                throw new DOMException('Sender was not created by this connection.',
+                    'InvalidAccessError');
+            }
+
+            // Search for the native stream the senders track belongs to.
+            pc._streams = pc._streams || {};
+            var stream;
+            Object.keys(pc._streams).forEach(function(streamid) {
+                var hasTrack = pc._streams[streamid].getTracks().find(function(track) {
+                    return sender.track === track;
+                });
+                if (hasTrack) {
+                    stream = pc._streams[streamid];
+                }
+            });
+
+            if (stream) {
+                if (stream.getTracks().length === 1) {
+                    // if this is the last track of the stream, remove the stream. This
+                    // takes care of any shimmed _senders.
+                    pc.removeStream(pc._reverseStreams[stream.id]);
+                } else {
+                    // relying on the same odd chrome behaviour as above.
+                    stream.removeTrack(sender.track);
+                }
+                pc.dispatchEvent(new Event('negotiationneeded'));
+            }
+        };
+    },
+
+    shimPeerConnection: function(window) {
+        var browserDetails = utils.detectBrowser(window);
+
+        // The RTCPeerConnection object.
+        if (!window.RTCPeerConnection && window.webkitRTCPeerConnection) {
+            window.RTCPeerConnection = function(pcConfig, pcConstraints) {
+                // Translate iceTransportPolicy to iceTransports,
+                // see https://code.google.com/p/webrtc/issues/detail?id=4869
+                // this was fixed in M56 along with unprefixing RTCPeerConnection.
+                logging('PeerConnection');
+                if (pcConfig && pcConfig.iceTransportPolicy) {
+                    pcConfig.iceTransports = pcConfig.iceTransportPolicy;
+                }
+
+                return new window.webkitRTCPeerConnection(pcConfig, pcConstraints);
+            };
+            window.RTCPeerConnection.prototype =
+                window.webkitRTCPeerConnection.prototype;
+            // wrap static methods. Currently just generateCertificate.
+            if (window.webkitRTCPeerConnection.generateCertificate) {
+                Object.defineProperty(window.RTCPeerConnection, 'generateCertificate', {
+                    get: function() {
+                        return window.webkitRTCPeerConnection.generateCertificate;
+                    }
+                });
+            }
+        } else {
+            // migrate from non-spec RTCIceServer.url to RTCIceServer.urls
+            var OrigPeerConnection = window.RTCPeerConnection;
+            window.RTCPeerConnection = function(pcConfig, pcConstraints) {
+                if (pcConfig && pcConfig.iceServers) {
+                    var newIceServers = [];
+                    for (var i = 0; i < pcConfig.iceServers.length; i++) {
+                        var server = pcConfig.iceServers[i];
+                        if (!server.hasOwnProperty('urls') &&
+                            server.hasOwnProperty('url')) {
+                            utils.deprecated('RTCIceServer.url', 'RTCIceServer.urls');
+                            server = JSON.parse(JSON.stringify(server));
+                            server.urls = server.url;
+                            newIceServers.push(server);
+                        } else {
+                            newIceServers.push(pcConfig.iceServers[i]);
+                        }
+                    }
+                    pcConfig.iceServers = newIceServers;
+                }
+                return new OrigPeerConnection(pcConfig, pcConstraints);
+            };
+            window.RTCPeerConnection.prototype = OrigPeerConnection.prototype;
+            // wrap static methods. Currently just generateCertificate.
+            Object.defineProperty(window.RTCPeerConnection, 'generateCertificate', {
+                get: function() {
+                    return OrigPeerConnection.generateCertificate;
+                }
+            });
+        }
+
+        var origGetStats = window.RTCPeerConnection.prototype.getStats;
+        window.RTCPeerConnection.prototype.getStats = function(selector,
+                                                               successCallback, errorCallback) {
+            var pc = this;
+            var args = arguments;
+
+            // If selector is a function then we are in the old style stats so just
+            // pass back the original getStats format to avoid breaking old users.
+            if (arguments.length > 0 && typeof selector === 'function') {
+                return origGetStats.apply(this, arguments);
+            }
+
+            // When spec-style getStats is supported, return those when called with
+            // either no arguments or the selector argument is null.
+            if (origGetStats.length === 0 && (arguments.length === 0 ||
+                typeof arguments[0] !== 'function')) {
+                return origGetStats.apply(this, []);
+            }
+
+            var fixChromeStats_ = function(response) {
+                var standardReport = {};
+                var reports = response.result();
+                reports.forEach(function(report) {
+                    var standardStats = {
+                        id: report.id,
+                        timestamp: report.timestamp,
+                        type: {
+                            localcandidate: 'local-candidate',
+                            remotecandidate: 'remote-candidate'
+                        }[report.type] || report.type
+                    };
+                    report.names().forEach(function(name) {
+                        standardStats[name] = report.stat(name);
+                    });
+                    standardReport[standardStats.id] = standardStats;
+                });
+
+                return standardReport;
+            };
+
+            // shim getStats with maplike support
+            var makeMapStats = function(stats) {
+                return new Map(Object.keys(stats).map(function(key) {
+                    return [key, stats[key]];
+                }));
+            };
+
+            if (arguments.length >= 2) {
+                var successCallbackWrapper_ = function(response) {
+                    args[1](makeMapStats(fixChromeStats_(response)));
+                };
+
+                return origGetStats.apply(this, [successCallbackWrapper_,
+                    arguments[0]]);
+            }
+
+            // promise-support
+            return new Promise(function(resolve, reject) {
+                origGetStats.apply(pc, [
+                    function(response) {
+                        resolve(makeMapStats(fixChromeStats_(response)));
+                    }, reject]);
+            }).then(successCallback, errorCallback);
+        };
+
+        // add promise support -- natively available in Chrome 51
+        if (browserDetails.version < 51) {
+            ['setLocalDescription', 'setRemoteDescription', 'addIceCandidate']
+                .forEach(function(method) {
+                    var nativeMethod = window.RTCPeerConnection.prototype[method];
+                    window.RTCPeerConnection.prototype[method] = function() {
+                        var args = arguments;
+                        var pc = this;
+                        var promise = new Promise(function(resolve, reject) {
+                            nativeMethod.apply(pc, [args[0], resolve, reject]);
+                        });
+                        if (args.length < 2) {
+                            return promise;
+                        }
+                        return promise.then(function() {
+                                args[1].apply(null, []);
+                            },
+                            function(err) {
+                                if (args.length >= 3) {
+                                    args[2].apply(null, [err]);
+                                }
+                            });
+                    };
+                });
+        }
+
+        // promise support for createOffer and createAnswer. Available (without
+        // bugs) since M52: crbug/619289
+        if (browserDetails.version < 52) {
+            ['createOffer', 'createAnswer'].forEach(function(method) {
+                var nativeMethod = window.RTCPeerConnection.prototype[method];
+                window.RTCPeerConnection.prototype[method] = function() {
+                    var pc = this;
+                    if (arguments.length < 1 || (arguments.length === 1 &&
+                        typeof arguments[0] === 'object')) {
+                        var opts = arguments.length === 1 ? arguments[0] : undefined;
+                        return new Promise(function(resolve, reject) {
+                            nativeMethod.apply(pc, [resolve, reject, opts]);
+                        });
+                    }
+                    return nativeMethod.apply(this, arguments);
+                };
+            });
+        }
+
+        // shim implicit creation of RTCSessionDescription/RTCIceCandidate
+        ['setLocalDescription', 'setRemoteDescription', 'addIceCandidate']
+            .forEach(function(method) {
+                var nativeMethod = window.RTCPeerConnection.prototype[method];
+                window.RTCPeerConnection.prototype[method] = function() {
+                    arguments[0] = new ((method === 'addIceCandidate') ?
+                        window.RTCIceCandidate :
+                        window.RTCSessionDescription)(arguments[0]);
+                    return nativeMethod.apply(this, arguments);
+                };
+            });
+
+        // support for addIceCandidate(null or undefined)
+        var nativeAddIceCandidate =
+            window.RTCPeerConnection.prototype.addIceCandidate;
+        window.RTCPeerConnection.prototype.addIceCandidate = function() {
+            if (!arguments[0]) {
+                if (arguments[1]) {
+                    arguments[1].apply(null);
+                }
+                return Promise.resolve();
+            }
+            return nativeAddIceCandidate.apply(this, arguments);
+        };
+    }
+};
+
+},{"../utils.js":13,"./getusermedia":6}],6:[function(require,module,exports){
+/*
+*  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+*
+*  Use of this source code is governed by a BSD-style license
+*  that can be found in the LICENSE file in the root of the source
+*  tree.
+*/
+/* eslint-env node */
+'use strict';
+var utils = require('../utils.js');
+var logging = utils.log;
+
+// Expose public methods.
+module.exports = function(window) {
+    var browserDetails = utils.detectBrowser(window);
+    var navigator = window && window.navigator;
+
+    var constraintsToChrome_ = function(c) {
+        if (typeof c !== 'object' || c.mandatory || c.optional) {
+            return c;
+        }
+        var cc = {};
+        Object.keys(c).forEach(function(key) {
+            if (key === 'require' || key === 'advanced' || key === 'mediaSource') {
+                return;
+            }
+            var r = (typeof c[key] === 'object') ? c[key] : {ideal: c[key]};
+            if (r.exact !== undefined && typeof r.exact === 'number') {
+                r.min = r.max = r.exact;
+            }
+            var oldname_ = function(prefix, name) {
+                if (prefix) {
+                    return prefix + name.charAt(0).toUpperCase() + name.slice(1);
+                }
+                return (name === 'deviceId') ? 'sourceId' : name;
+            };
+            if (r.ideal !== undefined) {
+                cc.optional = cc.optional || [];
+                var oc = {};
+                if (typeof r.ideal === 'number') {
+                    oc[oldname_('min', key)] = r.ideal;
+                    cc.optional.push(oc);
+                    oc = {};
+                    oc[oldname_('max', key)] = r.ideal;
+                    cc.optional.push(oc);
+                } else {
+                    oc[oldname_('', key)] = r.ideal;
+                    cc.optional.push(oc);
+                }
+            }
+            if (r.exact !== undefined && typeof r.exact !== 'number') {
+                cc.mandatory = cc.mandatory || {};
+                cc.mandatory[oldname_('', key)] = r.exact;
+            } else {
+                ['min', 'max'].forEach(function(mix) {
+                    if (r[mix] !== undefined) {
+                        cc.mandatory = cc.mandatory || {};
+                        cc.mandatory[oldname_(mix, key)] = r[mix];
+                    }
+                });
+            }
+        });
+        if (c.advanced) {
+            cc.optional = (cc.optional || []).concat(c.advanced);
+        }
+        return cc;
+    };
+
+    var shimConstraints_ = function(constraints, func) {
+        if (browserDetails.version >= 61) {
+            return func(constraints);
+        }
+        constraints = JSON.parse(JSON.stringify(constraints));
+        if (constraints && typeof constraints.audio === 'object') {
+            var remap = function(obj, a, b) {
+                if (a in obj && !(b in obj)) {
+                    obj[b] = obj[a];
+                    delete obj[a];
+                }
+            };
+            constraints = JSON.parse(JSON.stringify(constraints));
+            remap(constraints.audio, 'autoGainControl', 'googAutoGainControl');
+            remap(constraints.audio, 'noiseSuppression', 'googNoiseSuppression');
+            constraints.audio = constraintsToChrome_(constraints.audio);
+        }
+        if (constraints && typeof constraints.video === 'object') {
+            // Shim facingMode for mobile & surface pro.
+            var face = constraints.video.facingMode;
+            face = face && ((typeof face === 'object') ? face : {ideal: face});
+            var getSupportedFacingModeLies = browserDetails.version < 66;
+
+            if ((face && (face.exact === 'user' || face.exact === 'environment' ||
+                face.ideal === 'user' || face.ideal === 'environment')) &&
+                !(navigator.mediaDevices.getSupportedConstraints &&
+                    navigator.mediaDevices.getSupportedConstraints().facingMode &&
+                    !getSupportedFacingModeLies)) {
+                delete constraints.video.facingMode;
+                var matches;
+                if (face.exact === 'environment' || face.ideal === 'environment') {
+                    matches = ['back', 'rear'];
+                } else if (face.exact === 'user' || face.ideal === 'user') {
+                    matches = ['front'];
+                }
+                if (matches) {
+                    // Look for matches in label, or use last cam for back (typical).
+                    return navigator.mediaDevices.enumerateDevices()
+                        .then(function(devices) {
+                            devices = devices.filter(function(d) {
+                                return d.kind === 'videoinput';
+                            });
+                            var dev = devices.find(function(d) {
+                                return matches.some(function(match) {
+                                    return d.label.toLowerCase().indexOf(match) !== -1;
+                                });
+                            });
+                            if (!dev && devices.length && matches.indexOf('back') !== -1) {
+                                dev = devices[devices.length - 1]; // more likely the back cam
+                            }
+                            if (dev) {
+                                constraints.video.deviceId = face.exact ? {exact: dev.deviceId} :
+                                    {ideal: dev.deviceId};
+                            }
+                            constraints.video = constraintsToChrome_(constraints.video);
+                            logging('chrome: ' + JSON.stringify(constraints));
+                            return func(constraints);
+                        });
+                }
+            }
+            constraints.video = constraintsToChrome_(constraints.video);
+        }
+        logging('chrome: ' + JSON.stringify(constraints));
+        return func(constraints);
+    };
+
+    var shimError_ = function(e) {
+        return {
+            name: {
+                PermissionDeniedError: 'NotAllowedError',
+                PermissionDismissedError: 'NotAllowedError',
+                InvalidStateError: 'NotAllowedError',
+                DevicesNotFoundError: 'NotFoundError',
+                ConstraintNotSatisfiedError: 'OverconstrainedError',
+                TrackStartError: 'NotReadableError',
+                MediaDeviceFailedDueToShutdown: 'NotAllowedError',
+                MediaDeviceKillSwitchOn: 'NotAllowedError',
+                TabCaptureError: 'AbortError',
+                ScreenCaptureError: 'AbortError',
+                DeviceCaptureError: 'AbortError'
+            }[e.name] || e.name,
+            message: e.message,
+            constraint: e.constraintName,
+            toString: function() {
+                return this.name + (this.message && ': ') + this.message;
+            }
+        };
+    };
+
+    var getUserMedia_ = function(constraints, onSuccess, onError) {
+        shimConstraints_(constraints, function(c) {
+            navigator.webkitGetUserMedia(c, onSuccess, function(e) {
+                if (onError) {
+                    onError(shimError_(e));
+                }
+            });
+        });
+    };
+
+    navigator.getUserMedia = getUserMedia_;
+
+    // Returns the result of getUserMedia as a Promise.
+    var getUserMediaPromise_ = function(constraints) {
+        return new Promise(function(resolve, reject) {
+            navigator.getUserMedia(constraints, resolve, reject);
+        });
+    };
+
+    if (!navigator.mediaDevices) {
+        navigator.mediaDevices = {
+            getUserMedia: getUserMediaPromise_,
+            enumerateDevices: function() {
+                return new Promise(function(resolve) {
+                    var kinds = {audio: 'audioinput', video: 'videoinput'};
+                    return window.MediaStreamTrack.getSources(function(devices) {
+                        resolve(devices.map(function(device) {
+                            return {label: device.label,
+                                kind: kinds[device.kind],
+                                deviceId: device.id,
+                                groupId: ''};
+                        }));
+                    });
+                });
+            },
+            getSupportedConstraints: function() {
+                return {
+                    deviceId: true, echoCancellation: true, facingMode: true,
+                    frameRate: true, height: true, width: true
+                };
+            }
+        };
+    }
+
+    // A shim for getUserMedia method on the mediaDevices object.
+    // TODO(KaptenJansson) remove once implemented in Chrome stable.
+    if (!navigator.mediaDevices.getUserMedia) {
+        navigator.mediaDevices.getUserMedia = function(constraints) {
+            return getUserMediaPromise_(constraints);
+        };
+    } else {
+        // Even though Chrome 45 has navigator.mediaDevices and a getUserMedia
+        // function which returns a Promise, it does not accept spec-style
+        // constraints.
+        var origGetUserMedia = navigator.mediaDevices.getUserMedia.
+        bind(navigator.mediaDevices);
+        navigator.mediaDevices.getUserMedia = function(cs) {
+            return shimConstraints_(cs, function(c) {
+                return origGetUserMedia(c).then(function(stream) {
+                    if (c.audio && !stream.getAudioTracks().length ||
+                        c.video && !stream.getVideoTracks().length) {
+                        stream.getTracks().forEach(function(track) {
+                            track.stop();
+                        });
+                        throw new DOMException('', 'NotFoundError');
+                    }
+                    return stream;
+                }, function(e) {
+                    return Promise.reject(shimError_(e));
+                });
+            });
+        };
+    }
+
+    // Dummy devicechange event methods.
+    // TODO(KaptenJansson) remove once implemented in Chrome stable.
+    if (typeof navigator.mediaDevices.addEventListener === 'undefined') {
+        navigator.mediaDevices.addEventListener = function() {
+            logging('Dummy mediaDevices.addEventListener called.');
+        };
+    }
+    if (typeof navigator.mediaDevices.removeEventListener === 'undefined') {
+        navigator.mediaDevices.removeEventListener = function() {
+            logging('Dummy mediaDevices.removeEventListener called.');
+        };
+    }
+};
+
+},{"../utils.js":13}],7:[function(require,module,exports){
+/*
+*  Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
+*
+*  Use of this source code is governed by a BSD-style license
+*  that can be found in the LICENSE file in the root of the source
+*  tree.
+*/
+/* eslint-env node */
+'use strict';
+
+var SDPUtils = require('sdp');
+var utils = require('./utils');
+
+module.exports = {
+    shimRTCIceCandidate: function(window) {
+        // foundation is arbitrarily chosen as an indicator for full support for
+        // https://w3c.github.io/webrtc-pc/#rtcicecandidate-interface
+        if (!window.RTCIceCandidate || (window.RTCIceCandidate && 'foundation' in
+            window.RTCIceCandidate.prototype)) {
+            return;
+        }
+
+        var NativeRTCIceCandidate = window.RTCIceCandidate;
+        window.RTCIceCandidate = function(args) {
+            // Remove the a= which shouldn't be part of the candidate string.
+            if (typeof args === 'object' && args.candidate &&
+                args.candidate.indexOf('a=') === 0) {
+                args = JSON.parse(JSON.stringify(args));
+                args.candidate = args.candidate.substr(2);
+            }
+
+            if (args.candidate && args.candidate.length) {
+                // Augment the native candidate with the parsed fields.
+                var nativeCandidate = new NativeRTCIceCandidate(args);
+                var parsedCandidate = SDPUtils.parseCandidate(args.candidate);
+                var augmentedCandidate = Object.assign(nativeCandidate,
+                    parsedCandidate);
+
+                // Add a serializer that does not serialize the extra attributes.
+                augmentedCandidate.toJSON = function() {
+                    return {
+                        candidate: augmentedCandidate.candidate,
+                        sdpMid: augmentedCandidate.sdpMid,
+                        sdpMLineIndex: augmentedCandidate.sdpMLineIndex,
+                        usernameFragment: augmentedCandidate.usernameFragment,
+                    };
+                };
+                return augmentedCandidate;
+            }
+            return new NativeRTCIceCandidate(args);
+        };
+        window.RTCIceCandidate.prototype = NativeRTCIceCandidate.prototype;
+
+        // Hook up the augmented candidate in onicecandidate and
+        // addEventListener('icecandidate', ...)
+        utils.wrapPeerConnectionEvent(window, 'icecandidate', function(e) {
+            if (e.candidate) {
+                Object.defineProperty(e, 'candidate', {
+                    value: new window.RTCIceCandidate(e.candidate),
+                    writable: 'false'
+                });
+            }
+            return e;
+        });
+    },
+
+    // shimCreateObjectURL must be called before shimSourceObject to avoid loop.
+
+    shimCreateObjectURL: function(window) {
+        var URL = window && window.URL;
+
+        if (!(typeof window === 'object' && window.HTMLMediaElement &&
+            'srcObject' in window.HTMLMediaElement.prototype &&
+            URL.createObjectURL && URL.revokeObjectURL)) {
+            // Only shim CreateObjectURL using srcObject if srcObject exists.
+            return undefined;
+        }
+
+        var nativeCreateObjectURL = URL.createObjectURL.bind(URL);
+        var nativeRevokeObjectURL = URL.revokeObjectURL.bind(URL);
+        var streams = new Map(), newId = 0;
+
+        URL.createObjectURL = function(stream) {
+            if ('getTracks' in stream) {
+                var url = 'polyblob:' + (++newId);
+                streams.set(url, stream);
+                utils.deprecated('URL.createObjectURL(stream)',
+                    'elem.srcObject = stream');
+                return url;
+            }
+            return nativeCreateObjectURL(stream);
+        };
+        URL.revokeObjectURL = function(url) {
+            nativeRevokeObjectURL(url);
+            streams.delete(url);
+        };
+
+        var dsc = Object.getOwnPropertyDescriptor(window.HTMLMediaElement.prototype,
+            'src');
+        Object.defineProperty(window.HTMLMediaElement.prototype, 'src', {
+            get: function() {
+                return dsc.get.apply(this);
+            },
+            set: function(url) {
+                this.srcObject = streams.get(url) || null;
+                return dsc.set.apply(this, [url]);
+            }
+        });
+
+        var nativeSetAttribute = window.HTMLMediaElement.prototype.setAttribute;
+        window.HTMLMediaElement.prototype.setAttribute = function() {
+            if (arguments.length === 2 &&
+                ('' + arguments[0]).toLowerCase() === 'src') {
+                this.srcObject = streams.get(arguments[1]) || null;
+            }
+            return nativeSetAttribute.apply(this, arguments);
+        };
+    },
+
+    shimMaxMessageSize: function(window) {
+        if (window.RTCSctpTransport || !window.RTCPeerConnection) {
+            return;
+        }
+        var browserDetails = utils.detectBrowser(window);
+
+        if (!('sctp' in window.RTCPeerConnection.prototype)) {
+            Object.defineProperty(window.RTCPeerConnection.prototype, 'sctp', {
+                get: function() {
+                    return typeof this._sctp === 'undefined' ? null : this._sctp;
+                }
+            });
+        }
+
+        var sctpInDescription = function(description) {
+            var sections = SDPUtils.splitSections(description.sdp);
+            sections.shift();
+            return sections.some(function(mediaSection) {
+                var mLine = SDPUtils.parseMLine(mediaSection);
+                return mLine && mLine.kind === 'application'
+                    && mLine.protocol.indexOf('SCTP') !== -1;
+            });
+        };
+
+        var getRemoteFirefoxVersion = function(description) {
+            // TODO: Is there a better solution for detecting Firefox?
+            var match = description.sdp.match(/mozilla...THIS_IS_SDPARTA-(\d+)/);
+            if (match === null || match.length < 2) {
+                return -1;
+            }
+            var version = parseInt(match[1], 10);
+            // Test for NaN (yes, this is ugly)
+            return version !== version ? -1 : version;
+        };
+
+        var getCanSendMaxMessageSize = function(remoteIsFirefox) {
+            // Every implementation we know can send at least 64 KiB.
+            // Note: Although Chrome is technically able to send up to 256 KiB, the
+            //       data does not reach the other peer reliably.
+            //       See: https://bugs.chromium.org/p/webrtc/issues/detail?id=8419
+            var canSendMaxMessageSize = 65536;
+            if (browserDetails.browser === 'firefox') {
+                if (browserDetails.version < 57) {
+                    if (remoteIsFirefox === -1) {
+                        // FF < 57 will send in 16 KiB chunks using the deprecated PPID
+                        // fragmentation.
+                        canSendMaxMessageSize = 16384;
+                    } else {
+                        // However, other FF (and RAWRTC) can reassemble PPID-fragmented
+                        // messages. Thus, supporting ~2 GiB when sending.
+                        canSendMaxMessageSize = 2147483637;
+                    }
+                } else {
+                    // Currently, all FF >= 57 will reset the remote maximum message size
+                    // to the default value when a data channel is created at a later
+                    // stage. :(
+                    // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1426831
+                    canSendMaxMessageSize =
+                        browserDetails.version === 57 ? 65535 : 65536;
+                }
+            }
+            return canSendMaxMessageSize;
+        };
+
+        var getMaxMessageSize = function(description, remoteIsFirefox) {
+            // Note: 65536 bytes is the default value from the SDP spec. Also,
+            //       every implementation we know supports receiving 65536 bytes.
+            var maxMessageSize = 65536;
+
+            // FF 57 has a slightly incorrect default remote max message size, so
+            // we need to adjust it here to avoid a failure when sending.
+            // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1425697
+            if (browserDetails.browser === 'firefox'
+                && browserDetails.version === 57) {
+                maxMessageSize = 65535;
+            }
+
+            var match = SDPUtils.matchPrefix(description.sdp, 'a=max-message-size:');
+            if (match.length > 0) {
+                maxMessageSize = parseInt(match[0].substr(19), 10);
+            } else if (browserDetails.browser === 'firefox' &&
+                remoteIsFirefox !== -1) {
+                // If the maximum message size is not present in the remote SDP and
+                // both local and remote are Firefox, the remote peer can receive
+                // ~2 GiB.
+                maxMessageSize = 2147483637;
+            }
+            return maxMessageSize;
+        };
+
+        var origSetRemoteDescription =
+            window.RTCPeerConnection.prototype.setRemoteDescription;
+        window.RTCPeerConnection.prototype.setRemoteDescription = function() {
+            var pc = this;
+            pc._sctp = null;
+
+            if (sctpInDescription(arguments[0])) {
+                // Check if the remote is FF.
+                var isFirefox = getRemoteFirefoxVersion(arguments[0]);
+
+                // Get the maximum message size the local peer is capable of sending
+                var canSendMMS = getCanSendMaxMessageSize(isFirefox);
+
+                // Get the maximum message size of the remote peer.
+                var remoteMMS = getMaxMessageSize(arguments[0], isFirefox);
+
+                // Determine final maximum message size
+                var maxMessageSize;
+                if (canSendMMS === 0 && remoteMMS === 0) {
+                    maxMessageSize = Number.POSITIVE_INFINITY;
+                } else if (canSendMMS === 0 || remoteMMS === 0) {
+                    maxMessageSize = Math.max(canSendMMS, remoteMMS);
+                } else {
+                    maxMessageSize = Math.min(canSendMMS, remoteMMS);
+                }
+
+                // Create a dummy RTCSctpTransport object and the 'maxMessageSize'
+                // attribute.
+                var sctp = {};
+                Object.defineProperty(sctp, 'maxMessageSize', {
+                    get: function() {
+                        return maxMessageSize;
+                    }
+                });
+                pc._sctp = sctp;
+            }
+
+            return origSetRemoteDescription.apply(pc, arguments);
+        };
+    },
+
+    shimSendThrowTypeError: function(window) {
+        if (!(window.RTCPeerConnection &&
+            'createDataChannel' in window.RTCPeerConnection.prototype)) {
+            return;
+        }
+
+        // Note: Although Firefox >= 57 has a native implementation, the maximum
+        //       message size can be reset for all data channels at a later stage.
+        //       See: https://bugzilla.mozilla.org/show_bug.cgi?id=1426831
+
+        var origCreateDataChannel =
+            window.RTCPeerConnection.prototype.createDataChannel;
+        window.RTCPeerConnection.prototype.createDataChannel = function() {
+            var pc = this;
+            var dataChannel = origCreateDataChannel.apply(pc, arguments);
+            var origDataChannelSend = dataChannel.send;
+
+            // Patch 'send' method
+            dataChannel.send = function() {
+                var dc = this;
+                var data = arguments[0];
+                var length = data.length || data.size || data.byteLength;
+                if (length > pc.sctp.maxMessageSize) {
+                    throw new DOMException('Message too large (can send a maximum of ' +
+                        pc.sctp.maxMessageSize + ' bytes)', 'TypeError');
+                }
+                return origDataChannelSend.apply(dc, arguments);
+            };
+
+            return dataChannel;
+        };
+    }
+};
+
+},{"./utils":13,"sdp":2}],8:[function(require,module,exports){
+/*
+*  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+*
+*  Use of this source code is governed by a BSD-style license
+*  that can be found in the LICENSE file in the root of the source
+*  tree.
+*/
+/* eslint-env node */
+'use strict';
+
+var utils = require('../utils');
+var shimRTCPeerConnection = require('rtcpeerconnection-shim');
+
+module.exports = {
+    shimGetUserMedia: require('./getusermedia'),
+    shimPeerConnection: function(window) {
+        var browserDetails = utils.detectBrowser(window);
+
+        if (window.RTCIceGatherer) {
+            if (!window.RTCIceCandidate) {
+                window.RTCIceCandidate = function(args) {
+                    return args;
+                };
+            }
+            if (!window.RTCSessionDescription) {
+                window.RTCSessionDescription = function(args) {
+                    return args;
+                };
+            }
+            // this adds an additional event listener to MediaStrackTrack that signals
+            // when a tracks enabled property was changed. Workaround for a bug in
+            // addStream, see below. No longer required in 15025+
+            if (browserDetails.version < 15025) {
+                var origMSTEnabled = Object.getOwnPropertyDescriptor(
+                    window.MediaStreamTrack.prototype, 'enabled');
+                Object.defineProperty(window.MediaStreamTrack.prototype, 'enabled', {
+                    set: function(value) {
+                        origMSTEnabled.set.call(this, value);
+                        var ev = new Event('enabled');
+                        ev.enabled = value;
+                        this.dispatchEvent(ev);
+                    }
+                });
+            }
+        }
+
+        // ORTC defines the DTMF sender a bit different.
+        // https://github.com/w3c/ortc/issues/714
+        if (window.RTCRtpSender && !('dtmf' in window.RTCRtpSender.prototype)) {
+            Object.defineProperty(window.RTCRtpSender.prototype, 'dtmf', {
+                get: function() {
+                    if (this._dtmf === undefined) {
+                        if (this.track.kind === 'audio') {
+                            this._dtmf = new window.RTCDtmfSender(this);
+                        } else if (this.track.kind === 'video') {
+                            this._dtmf = null;
+                        }
+                    }
+                    return this._dtmf;
+                }
+            });
+        }
+        // Edge currently only implements the RTCDtmfSender, not the
+        // RTCDTMFSender alias. See http://draft.ortc.org/#rtcdtmfsender2*
+        if (window.RTCDtmfSender && !window.RTCDTMFSender) {
+            window.RTCDTMFSender = window.RTCDtmfSender;
+        }
+
+        window.RTCPeerConnection =
+            shimRTCPeerConnection(window, browserDetails.version);
+    },
+    shimReplaceTrack: function(window) {
+        // ORTC has replaceTrack -- https://github.com/w3c/ortc/issues/614
+        if (window.RTCRtpSender &&
+            !('replaceTrack' in window.RTCRtpSender.prototype)) {
+            window.RTCRtpSender.prototype.replaceTrack =
+                window.RTCRtpSender.prototype.setTrack;
+        }
+    }
+};
+
+},{"../utils":13,"./getusermedia":9,"rtcpeerconnection-shim":1}],9:[function(require,module,exports){
+/*
+*  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+*
+*  Use of this source code is governed by a BSD-style license
+*  that can be found in the LICENSE file in the root of the source
+*  tree.
+*/
+/* eslint-env node */
+'use strict';
+
+// Expose public methods.
+module.exports = function(window) {
+    var navigator = window && window.navigator;
+
+    var shimError_ = function(e) {
+        return {
+            name: {PermissionDeniedError: 'NotAllowedError'}[e.name] || e.name,
+            message: e.message,
+            constraint: e.constraint,
+            toString: function() {
+                return this.name;
+            }
+        };
+    };
+
+    // getUserMedia error shim.
+    var origGetUserMedia = navigator.mediaDevices.getUserMedia.
+    bind(navigator.mediaDevices);
+    navigator.mediaDevices.getUserMedia = function(c) {
+        return origGetUserMedia(c).catch(function(e) {
+            return Promise.reject(shimError_(e));
+        });
+    };
+};
+
+},{}],10:[function(require,module,exports){
+/*
+*  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+*
+*  Use of this source code is governed by a BSD-style license
+*  that can be found in the LICENSE file in the root of the source
+*  tree.
+*/
+/* eslint-env node */
+'use strict';
+
+var utils = require('../utils');
+
+module.exports = {
+    shimGetUserMedia: require('./getusermedia'),
+    shimOnTrack: function(window) {
+        if (typeof window === 'object' && window.RTCPeerConnection && !('ontrack' in
+            window.RTCPeerConnection.prototype)) {
+            Object.defineProperty(window.RTCPeerConnection.prototype, 'ontrack', {
+                get: function() {
+                    return this._ontrack;
+                },
+                set: function(f) {
+                    if (this._ontrack) {
+                        this.removeEventListener('track', this._ontrack);
+                        this.removeEventListener('addstream', this._ontrackpoly);
+                    }
+                    this.addEventListener('track', this._ontrack = f);
+                    this.addEventListener('addstream', this._ontrackpoly = function(e) {
+                        e.stream.getTracks().forEach(function(track) {
+                            var event = new Event('track');
+                            event.track = track;
+                            event.receiver = {track: track};
+                            event.transceiver = {receiver: event.receiver};
+                            event.streams = [e.stream];
+                            this.dispatchEvent(event);
+                        }.bind(this));
+                    }.bind(this));
+                }
+            });
+        }
+        if (typeof window === 'object' && window.RTCTrackEvent &&
+            ('receiver' in window.RTCTrackEvent.prototype) &&
+            !('transceiver' in window.RTCTrackEvent.prototype)) {
+            Object.defineProperty(window.RTCTrackEvent.prototype, 'transceiver', {
+                get: function() {
+                    return {receiver: this.receiver};
+                }
+            });
+        }
+    },
+
+    shimSourceObject: function(window) {
+        // Firefox has supported mozSrcObject since FF22, unprefixed in 42.
+        if (typeof window === 'object') {
+            if (window.HTMLMediaElement &&
+                !('srcObject' in window.HTMLMediaElement.prototype)) {
+                // Shim the srcObject property, once, when HTMLMediaElement is found.
+                Object.defineProperty(window.HTMLMediaElement.prototype, 'srcObject', {
+                    get: function() {
+                        return this.mozSrcObject;
+                    },
+                    set: function(stream) {
+                        this.mozSrcObject = stream;
+                    }
+                });
+            }
+        }
+    },
+
+    shimPeerConnection: function(window) {
+        var browserDetails = utils.detectBrowser(window);
+
+        if (typeof window !== 'object' || !(window.RTCPeerConnection ||
+            window.mozRTCPeerConnection)) {
+            return; // probably media.peerconnection.enabled=false in about:config
+        }
+        // The RTCPeerConnection object.
+        if (!window.RTCPeerConnection) {
+            window.RTCPeerConnection = function(pcConfig, pcConstraints) {
+                if (browserDetails.version < 38) {
+                    // .urls is not supported in FF < 38.
+                    // create RTCIceServers with a single url.
+                    if (pcConfig && pcConfig.iceServers) {
+                        var newIceServers = [];
+                        for (var i = 0; i < pcConfig.iceServers.length; i++) {
+                            var server = pcConfig.iceServers[i];
+                            if (server.hasOwnProperty('urls')) {
+                                for (var j = 0; j < server.urls.length; j++) {
+                                    var newServer = {
+                                        url: server.urls[j]
+                                    };
+                                    if (server.urls[j].indexOf('turn') === 0) {
+                                        newServer.username = server.username;
+                                        newServer.credential = server.credential;
+                                    }
+                                    newIceServers.push(newServer);
+                                }
+                            } else {
+                                newIceServers.push(pcConfig.iceServers[i]);
+                            }
+                        }
+                        pcConfig.iceServers = newIceServers;
+                    }
+                }
+                return new window.mozRTCPeerConnection(pcConfig, pcConstraints);
+            };
+            window.RTCPeerConnection.prototype =
+                window.mozRTCPeerConnection.prototype;
+
+            // wrap static methods. Currently just generateCertificate.
+            if (window.mozRTCPeerConnection.generateCertificate) {
+                Object.defineProperty(window.RTCPeerConnection, 'generateCertificate', {
+                    get: function() {
+                        return window.mozRTCPeerConnection.generateCertificate;
+                    }
+                });
+            }
+
+            window.RTCSessionDescription = window.mozRTCSessionDescription;
+            window.RTCIceCandidate = window.mozRTCIceCandidate;
+        }
+
+        // shim away need for obsolete RTCIceCandidate/RTCSessionDescription.
+        ['setLocalDescription', 'setRemoteDescription', 'addIceCandidate']
+            .forEach(function(method) {
+                var nativeMethod = window.RTCPeerConnection.prototype[method];
+                window.RTCPeerConnection.prototype[method] = function() {
+                    arguments[0] = new ((method === 'addIceCandidate') ?
+                        window.RTCIceCandidate :
+                        window.RTCSessionDescription)(arguments[0]);
+                    return nativeMethod.apply(this, arguments);
+                };
+            });
+
+        // support for addIceCandidate(null or undefined)
+        var nativeAddIceCandidate =
+            window.RTCPeerConnection.prototype.addIceCandidate;
+        window.RTCPeerConnection.prototype.addIceCandidate = function() {
+            if (!arguments[0]) {
+                if (arguments[1]) {
+                    arguments[1].apply(null);
+                }
+                return Promise.resolve();
+            }
+            return nativeAddIceCandidate.apply(this, arguments);
+        };
+
+        // shim getStats with maplike support
+        var makeMapStats = function(stats) {
+            var map = new Map();
+            Object.keys(stats).forEach(function(key) {
+                map.set(key, stats[key]);
+                map[key] = stats[key];
+            });
+            return map;
+        };
+
+        var modernStatsTypes = {
+            inboundrtp: 'inbound-rtp',
+            outboundrtp: 'outbound-rtp',
+            candidatepair: 'candidate-pair',
+            localcandidate: 'local-candidate',
+            remotecandidate: 'remote-candidate'
+        };
+
+        var nativeGetStats = window.RTCPeerConnection.prototype.getStats;
+        window.RTCPeerConnection.prototype.getStats = function(
+            selector,
+            onSucc,
+            onErr
+        ) {
+            return nativeGetStats.apply(this, [selector || null])
+                .then(function(stats) {
+                    if (browserDetails.version < 48) {
+                        stats = makeMapStats(stats);
+                    }
+                    if (browserDetails.version < 53 && !onSucc) {
+                        // Shim only promise getStats with spec-hyphens in type names
+                        // Leave callback version alone; misc old uses of forEach before Map
+                        try {
+                            stats.forEach(function(stat) {
+                                stat.type = modernStatsTypes[stat.type] || stat.type;
+                            });
+                        } catch (e) {
+                            if (e.name !== 'TypeError') {
+                                throw e;
+                            }
+                            // Avoid TypeError: "type" is read-only, in old versions. 34-43ish
+                            stats.forEach(function(stat, i) {
+                                stats.set(i, Object.assign({}, stat, {
+                                    type: modernStatsTypes[stat.type] || stat.type
+                                }));
+                            });
+                        }
+                    }
+                    return stats;
+                })
+                .then(onSucc, onErr);
+        };
+    },
+
+    shimRemoveStream: function(window) {
+        if (!window.RTCPeerConnection ||
+            'removeStream' in window.RTCPeerConnection.prototype) {
+            return;
+        }
+        window.RTCPeerConnection.prototype.removeStream = function(stream) {
+            var pc = this;
+            utils.deprecated('removeStream', 'removeTrack');
+            this.getSenders().forEach(function(sender) {
+                if (sender.track && stream.getTracks().indexOf(sender.track) !== -1) {
+                    pc.removeTrack(sender);
+                }
+            });
+        };
+    }
+};
+
+},{"../utils":13,"./getusermedia":11}],11:[function(require,module,exports){
+/*
+*  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+*
+*  Use of this source code is governed by a BSD-style license
+*  that can be found in the LICENSE file in the root of the source
+*  tree.
+*/
+/* eslint-env node */
+'use strict';
+
+var utils = require('../utils');
+var logging = utils.log;
+
+// Expose public methods.
+module.exports = function(window) {
+    var browserDetails = utils.detectBrowser(window);
+    var navigator = window && window.navigator;
+    var MediaStreamTrack = window && window.MediaStreamTrack;
+
+    var shimError_ = function(e) {
+        return {
+            name: {
+                InternalError: 'NotReadableError',
+                NotSupportedError: 'TypeError',
+                PermissionDeniedError: 'NotAllowedError',
+                SecurityError: 'NotAllowedError'
+            }[e.name] || e.name,
+            message: {
+                'The operation is insecure.': 'The request is not allowed by the ' +
+                'user agent or the platform in the current context.'
+            }[e.message] || e.message,
+            constraint: e.constraint,
+            toString: function() {
+                return this.name + (this.message && ': ') + this.message;
+            }
+        };
+    };
+
+    // getUserMedia constraints shim.
+    var getUserMedia_ = function(constraints, onSuccess, onError) {
+        var constraintsToFF37_ = function(c) {
+            if (typeof c !== 'object' || c.require) {
+                return c;
+            }
+            var require = [];
+            Object.keys(c).forEach(function(key) {
+                if (key === 'require' || key === 'advanced' || key === 'mediaSource') {
+                    return;
+                }
+                var r = c[key] = (typeof c[key] === 'object') ?
+                    c[key] : {ideal: c[key]};
+                if (r.min !== undefined ||
+                    r.max !== undefined || r.exact !== undefined) {
+                    require.push(key);
+                }
+                if (r.exact !== undefined) {
+                    if (typeof r.exact === 'number') {
+                        r. min = r.max = r.exact;
+                    } else {
+                        c[key] = r.exact;
+                    }
+                    delete r.exact;
+                }
+                if (r.ideal !== undefined) {
+                    c.advanced = c.advanced || [];
+                    var oc = {};
+                    if (typeof r.ideal === 'number') {
+                        oc[key] = {min: r.ideal, max: r.ideal};
+                    } else {
+                        oc[key] = r.ideal;
+                    }
+                    c.advanced.push(oc);
+                    delete r.ideal;
+                    if (!Object.keys(r).length) {
+                        delete c[key];
+                    }
+                }
+            });
+            if (require.length) {
+                c.require = require;
+            }
+            return c;
+        };
+        constraints = JSON.parse(JSON.stringify(constraints));
+        if (browserDetails.version < 38) {
+            logging('spec: ' + JSON.stringify(constraints));
+            if (constraints.audio) {
+                constraints.audio = constraintsToFF37_(constraints.audio);
+            }
+            if (constraints.video) {
+                constraints.video = constraintsToFF37_(constraints.video);
+            }
+            logging('ff37: ' + JSON.stringify(constraints));
+        }
+        return navigator.mozGetUserMedia(constraints, onSuccess, function(e) {
+            onError(shimError_(e));
+        });
+    };
+
+    // Returns the result of getUserMedia as a Promise.
+    var getUserMediaPromise_ = function(constraints) {
+        return new Promise(function(resolve, reject) {
+            getUserMedia_(constraints, resolve, reject);
+        });
+    };
+
+    // Shim for mediaDevices on older versions.
+    if (!navigator.mediaDevices) {
+        navigator.mediaDevices = {getUserMedia: getUserMediaPromise_,
+            addEventListener: function() { },
+            removeEventListener: function() { }
+        };
+    }
+    navigator.mediaDevices.enumerateDevices =
+        navigator.mediaDevices.enumerateDevices || function() {
+            return new Promise(function(resolve) {
+                var infos = [
+                    {kind: 'audioinput', deviceId: 'default', label: '', groupId: ''},
+                    {kind: 'videoinput', deviceId: 'default', label: '', groupId: ''}
+                ];
+                resolve(infos);
+            });
+        };
+
+    if (browserDetails.version < 41) {
+        // Work around http://bugzil.la/1169665
+        var orgEnumerateDevices =
+            navigator.mediaDevices.enumerateDevices.bind(navigator.mediaDevices);
+        navigator.mediaDevices.enumerateDevices = function() {
+            return orgEnumerateDevices().then(undefined, function(e) {
+                if (e.name === 'NotFoundError') {
+                    return [];
+                }
+                throw e;
+            });
+        };
+    }
+    if (browserDetails.version < 49) {
+        var origGetUserMedia = navigator.mediaDevices.getUserMedia.
+        bind(navigator.mediaDevices);
+        navigator.mediaDevices.getUserMedia = function(c) {
+            return origGetUserMedia(c).then(function(stream) {
+                // Work around https://bugzil.la/802326
+                if (c.audio && !stream.getAudioTracks().length ||
+                    c.video && !stream.getVideoTracks().length) {
+                    stream.getTracks().forEach(function(track) {
+                        track.stop();
+                    });
+                    throw new DOMException('The object can not be found here.',
+                        'NotFoundError');
+                }
+                return stream;
+            }, function(e) {
+                return Promise.reject(shimError_(e));
+            });
+        };
+    }
+    if (!(browserDetails.version > 55 &&
+        'autoGainControl' in navigator.mediaDevices.getSupportedConstraints())) {
+        var remap = function(obj, a, b) {
+            if (a in obj && !(b in obj)) {
+                obj[b] = obj[a];
+                delete obj[a];
+            }
+        };
+
+        var nativeGetUserMedia = navigator.mediaDevices.getUserMedia.
+        bind(navigator.mediaDevices);
+        navigator.mediaDevices.getUserMedia = function(c) {
+            if (typeof c === 'object' && typeof c.audio === 'object') {
+                c = JSON.parse(JSON.stringify(c));
+                remap(c.audio, 'autoGainControl', 'mozAutoGainControl');
+                remap(c.audio, 'noiseSuppression', 'mozNoiseSuppression');
+            }
+            return nativeGetUserMedia(c);
+        };
+
+        if (MediaStreamTrack && MediaStreamTrack.prototype.getSettings) {
+            var nativeGetSettings = MediaStreamTrack.prototype.getSettings;
+            MediaStreamTrack.prototype.getSettings = function() {
+                var obj = nativeGetSettings.apply(this, arguments);
+                remap(obj, 'mozAutoGainControl', 'autoGainControl');
+                remap(obj, 'mozNoiseSuppression', 'noiseSuppression');
+                return obj;
+            };
+        }
+
+        if (MediaStreamTrack && MediaStreamTrack.prototype.applyConstraints) {
+            var nativeApplyConstraints = MediaStreamTrack.prototype.applyConstraints;
+            MediaStreamTrack.prototype.applyConstraints = function(c) {
+                if (this.kind === 'audio' && typeof c === 'object') {
+                    c = JSON.parse(JSON.stringify(c));
+                    remap(c, 'autoGainControl', 'mozAutoGainControl');
+                    remap(c, 'noiseSuppression', 'mozNoiseSuppression');
+                }
+                return nativeApplyConstraints.apply(this, [c]);
+            };
+        }
+    }
+    navigator.getUserMedia = function(constraints, onSuccess, onError) {
+        if (browserDetails.version < 44) {
+            return getUserMedia_(constraints, onSuccess, onError);
+        }
+        // Replace Firefox 44+'s deprecation warning with unprefixed version.
+        utils.deprecated('navigator.getUserMedia',
+            'navigator.mediaDevices.getUserMedia');
+        navigator.mediaDevices.getUserMedia(constraints).then(onSuccess, onError);
+    };
+};
+
+},{"../utils":13}],12:[function(require,module,exports){
+/*
+*  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+*
+*  Use of this source code is governed by a BSD-style license
+*  that can be found in the LICENSE file in the root of the source
+*  tree.
+*/
+'use strict';
+var utils = require('../utils');
+
+module.exports = {
+    shimLocalStreamsAPI: function(window) {
+        if (typeof window !== 'object' || !window.RTCPeerConnection) {
+            return;
+        }
+        if (!('getLocalStreams' in window.RTCPeerConnection.prototype)) {
+            window.RTCPeerConnection.prototype.getLocalStreams = function() {
+                if (!this._localStreams) {
+                    this._localStreams = [];
+                }
+                return this._localStreams;
+            };
+        }
+        if (!('getStreamById' in window.RTCPeerConnection.prototype)) {
+            window.RTCPeerConnection.prototype.getStreamById = function(id) {
+                var result = null;
+                if (this._localStreams) {
+                    this._localStreams.forEach(function(stream) {
+                        if (stream.id === id) {
+                            result = stream;
+                        }
+                    });
+                }
+                if (this._remoteStreams) {
+                    this._remoteStreams.forEach(function(stream) {
+                        if (stream.id === id) {
+                            result = stream;
+                        }
+                    });
+                }
+                return result;
+            };
+        }
+        if (!('addStream' in window.RTCPeerConnection.prototype)) {
+            var _addTrack = window.RTCPeerConnection.prototype.addTrack;
+            window.RTCPeerConnection.prototype.addStream = function(stream) {
+                if (!this._localStreams) {
+                    this._localStreams = [];
+                }
+                if (this._localStreams.indexOf(stream) === -1) {
+                    this._localStreams.push(stream);
+                }
+                var pc = this;
+                stream.getTracks().forEach(function(track) {
+                    _addTrack.call(pc, track, stream);
+                });
+            };
+
+            window.RTCPeerConnection.prototype.addTrack = function(track, stream) {
+                if (stream) {
+                    if (!this._localStreams) {
+                        this._localStreams = [stream];
+                    } else if (this._localStreams.indexOf(stream) === -1) {
+                        this._localStreams.push(stream);
+                    }
+                }
+                return _addTrack.call(this, track, stream);
+            };
+        }
+        if (!('removeStream' in window.RTCPeerConnection.prototype)) {
+            window.RTCPeerConnection.prototype.removeStream = function(stream) {
+                if (!this._localStreams) {
+                    this._localStreams = [];
+                }
+                var index = this._localStreams.indexOf(stream);
+                if (index === -1) {
+                    return;
+                }
+                this._localStreams.splice(index, 1);
+                var pc = this;
+                var tracks = stream.getTracks();
+                this.getSenders().forEach(function(sender) {
+                    if (tracks.indexOf(sender.track) !== -1) {
+                        pc.removeTrack(sender);
+                    }
+                });
+            };
+        }
+    },
+    shimRemoteStreamsAPI: function(window) {
+        if (typeof window !== 'object' || !window.RTCPeerConnection) {
+            return;
+        }
+        if (!('getRemoteStreams' in window.RTCPeerConnection.prototype)) {
+            window.RTCPeerConnection.prototype.getRemoteStreams = function() {
+                return this._remoteStreams ? this._remoteStreams : [];
+            };
+        }
+        if (!('onaddstream' in window.RTCPeerConnection.prototype)) {
+            Object.defineProperty(window.RTCPeerConnection.prototype, 'onaddstream', {
+                get: function() {
+                    return this._onaddstream;
+                },
+                set: function(f) {
+                    var pc = this;
+                    if (this._onaddstream) {
+                        this.removeEventListener('addstream', this._onaddstream);
+                        this.removeEventListener('track', this._onaddstreampoly);
+                    }
+                    this.addEventListener('addstream', this._onaddstream = f);
+                    this.addEventListener('track', this._onaddstreampoly = function(e) {
+                        e.streams.forEach(function(stream) {
+                            if (!pc._remoteStreams) {
+                                pc._remoteStreams = [];
+                            }
+                            if (pc._remoteStreams.indexOf(stream) >= 0) {
+                                return;
+                            }
+                            pc._remoteStreams.push(stream);
+                            var event = new Event('addstream');
+                            event.stream = stream;
+                            pc.dispatchEvent(event);
+                        });
+                    });
+                }
+            });
+        }
+    },
+    shimCallbacksAPI: function(window) {
+        if (typeof window !== 'object' || !window.RTCPeerConnection) {
+            return;
+        }
+        var prototype = window.RTCPeerConnection.prototype;
+        var createOffer = prototype.createOffer;
+        var createAnswer = prototype.createAnswer;
+        var setLocalDescription = prototype.setLocalDescription;
+        var setRemoteDescription = prototype.setRemoteDescription;
+        var addIceCandidate = prototype.addIceCandidate;
+
+        prototype.createOffer = function(successCallback, failureCallback) {
+            var options = (arguments.length >= 2) ? arguments[2] : arguments[0];
+            var promise = createOffer.apply(this, [options]);
+            if (!failureCallback) {
+                return promise;
+            }
+            promise.then(successCallback, failureCallback);
+            return Promise.resolve();
+        };
+
+        prototype.createAnswer = function(successCallback, failureCallback) {
+            var options = (arguments.length >= 2) ? arguments[2] : arguments[0];
+            var promise = createAnswer.apply(this, [options]);
+            if (!failureCallback) {
+                return promise;
+            }
+            promise.then(successCallback, failureCallback);
+            return Promise.resolve();
+        };
+
+        var withCallback = function(description, successCallback, failureCallback) {
+            var promise = setLocalDescription.apply(this, [description]);
+            if (!failureCallback) {
+                return promise;
+            }
+            promise.then(successCallback, failureCallback);
+            return Promise.resolve();
+        };
+        prototype.setLocalDescription = withCallback;
+
+        withCallback = function(description, successCallback, failureCallback) {
+            var promise = setRemoteDescription.apply(this, [description]);
+            if (!failureCallback) {
+                return promise;
+            }
+            promise.then(successCallback, failureCallback);
+            return Promise.resolve();
+        };
+        prototype.setRemoteDescription = withCallback;
+
+        withCallback = function(candidate, successCallback, failureCallback) {
+            var promise = addIceCandidate.apply(this, [candidate]);
+            if (!failureCallback) {
+                return promise;
+            }
+            promise.then(successCallback, failureCallback);
+            return Promise.resolve();
+        };
+        prototype.addIceCandidate = withCallback;
+    },
+    shimGetUserMedia: function(window) {
+        var navigator = window && window.navigator;
+
+        if (!navigator.getUserMedia) {
+            if (navigator.webkitGetUserMedia) {
+                navigator.getUserMedia = navigator.webkitGetUserMedia.bind(navigator);
+            } else if (navigator.mediaDevices &&
+                navigator.mediaDevices.getUserMedia) {
+                navigator.getUserMedia = function(constraints, cb, errcb) {
+                    navigator.mediaDevices.getUserMedia(constraints)
+                        .then(cb, errcb);
+                }.bind(navigator);
+            }
+        }
+    },
+    shimRTCIceServerUrls: function(window) {
+        // migrate from non-spec RTCIceServer.url to RTCIceServer.urls
+        var OrigPeerConnection = window.RTCPeerConnection;
+        window.RTCPeerConnection = function(pcConfig, pcConstraints) {
+            if (pcConfig && pcConfig.iceServers) {
+                var newIceServers = [];
+                for (var i = 0; i < pcConfig.iceServers.length; i++) {
+                    var server = pcConfig.iceServers[i];
+                    if (!server.hasOwnProperty('urls') &&
+                        server.hasOwnProperty('url')) {
+                        utils.deprecated('RTCIceServer.url', 'RTCIceServer.urls');
+                        server = JSON.parse(JSON.stringify(server));
+                        server.urls = server.url;
+                        delete server.url;
+                        newIceServers.push(server);
+                    } else {
+                        newIceServers.push(pcConfig.iceServers[i]);
+                    }
+                }
+                pcConfig.iceServers = newIceServers;
+            }
+            return new OrigPeerConnection(pcConfig, pcConstraints);
+        };
+        window.RTCPeerConnection.prototype = OrigPeerConnection.prototype;
+        // wrap static methods. Currently just generateCertificate.
+        if ('generateCertificate' in window.RTCPeerConnection) {
+            Object.defineProperty(window.RTCPeerConnection, 'generateCertificate', {
+                get: function() {
+                    return OrigPeerConnection.generateCertificate;
+                }
+            });
+        }
+    },
+    shimTrackEventTransceiver: function(window) {
+        // Add event.transceiver member over deprecated event.receiver
+        if (typeof window === 'object' && window.RTCPeerConnection &&
+            ('receiver' in window.RTCTrackEvent.prototype) &&
+            // can't check 'transceiver' in window.RTCTrackEvent.prototype, as it is
+            // defined for some reason even when window.RTCTransceiver is not.
+            !window.RTCTransceiver) {
+            Object.defineProperty(window.RTCTrackEvent.prototype, 'transceiver', {
+                get: function() {
+                    return {receiver: this.receiver};
+                }
+            });
+        }
+    },
+
+    shimCreateOfferLegacy: function(window) {
+        var origCreateOffer = window.RTCPeerConnection.prototype.createOffer;
+        window.RTCPeerConnection.prototype.createOffer = function(offerOptions) {
+            var pc = this;
+            if (offerOptions) {
+                if (typeof offerOptions.offerToReceiveAudio !== 'undefined') {
+                    // support bit values
+                    offerOptions.offerToReceiveAudio = !!offerOptions.offerToReceiveAudio;
+                }
+                var audioTransceiver = pc.getTransceivers().find(function(transceiver) {
+                    return transceiver.sender.track &&
+                        transceiver.sender.track.kind === 'audio';
+                });
+                if (offerOptions.offerToReceiveAudio === false && audioTransceiver) {
+                    if (audioTransceiver.direction === 'sendrecv') {
+                        if (audioTransceiver.setDirection) {
+                            audioTransceiver.setDirection('sendonly');
+                        } else {
+                            audioTransceiver.direction = 'sendonly';
+                        }
+                    } else if (audioTransceiver.direction === 'recvonly') {
+                        if (audioTransceiver.setDirection) {
+                            audioTransceiver.setDirection('inactive');
+                        } else {
+                            audioTransceiver.direction = 'inactive';
+                        }
+                    }
+                } else if (offerOptions.offerToReceiveAudio === true &&
+                    !audioTransceiver) {
+                    pc.addTransceiver('audio');
+                }
+
+
+                if (typeof offerOptions.offerToReceiveAudio !== 'undefined') {
+                    // support bit values
+                    offerOptions.offerToReceiveVideo = !!offerOptions.offerToReceiveVideo;
+                }
+                var videoTransceiver = pc.getTransceivers().find(function(transceiver) {
+                    return transceiver.sender.track &&
+                        transceiver.sender.track.kind === 'video';
+                });
+                if (offerOptions.offerToReceiveVideo === false && videoTransceiver) {
+                    if (videoTransceiver.direction === 'sendrecv') {
+                        videoTransceiver.setDirection('sendonly');
+                    } else if (videoTransceiver.direction === 'recvonly') {
+                        videoTransceiver.setDirection('inactive');
+                    }
+                } else if (offerOptions.offerToReceiveVideo === true &&
+                    !videoTransceiver) {
+                    pc.addTransceiver('video');
+                }
+            }
+            return origCreateOffer.apply(pc, arguments);
+        };
+    }
+};
+
+},{"../utils":13}],13:[function(require,module,exports){
+/*
+*  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+*
+*  Use of this source code is governed by a BSD-style license
+*  that can be found in the LICENSE file in the root of the source
+*  tree.
+*/
+/* eslint-env node */
+'use strict';
+
+var logDisabled_ = true;
+var deprecationWarnings_ = true;
+
+/**
+ * Extract browser version out of the provided user agent string.
+ *
+ * @param {!string} uastring userAgent string.
+ * @param {!string} expr Regular expression used as match criteria.
+ * @param {!number} pos position in the version string to be returned.
+ * @return {!number} browser version.
+ */
+function extractVersion(uastring, expr, pos) {
+    var match = uastring.match(expr);
+    return match && match.length >= pos && parseInt(match[pos], 10);
+}
+
+// Wraps the peerconnection event eventNameToWrap in a function
+// which returns the modified event object.
+function wrapPeerConnectionEvent(window, eventNameToWrap, wrapper) {
+    if (!window.RTCPeerConnection) {
+        return;
+    }
+    var proto = window.RTCPeerConnection.prototype;
+    var nativeAddEventListener = proto.addEventListener;
+    proto.addEventListener = function(nativeEventName, cb) {
+        if (nativeEventName !== eventNameToWrap) {
+            return nativeAddEventListener.apply(this, arguments);
+        }
+        var wrappedCallback = function(e) {
+            cb(wrapper(e));
+        };
+        this._eventMap = this._eventMap || {};
+        this._eventMap[cb] = wrappedCallback;
+        return nativeAddEventListener.apply(this, [nativeEventName,
+            wrappedCallback]);
+    };
+
+    var nativeRemoveEventListener = proto.removeEventListener;
+    proto.removeEventListener = function(nativeEventName, cb) {
+        if (nativeEventName !== eventNameToWrap || !this._eventMap
+            || !this._eventMap[cb]) {
+            return nativeRemoveEventListener.apply(this, arguments);
+        }
+        var unwrappedCb = this._eventMap[cb];
+        delete this._eventMap[cb];
+        return nativeRemoveEventListener.apply(this, [nativeEventName,
+            unwrappedCb]);
+    };
+
+    Object.defineProperty(proto, 'on' + eventNameToWrap, {
+        get: function() {
+            return this['_on' + eventNameToWrap];
+        },
+        set: function(cb) {
+            if (this['_on' + eventNameToWrap]) {
+                this.removeEventListener(eventNameToWrap,
+                    this['_on' + eventNameToWrap]);
+                delete this['_on' + eventNameToWrap];
+            }
+            if (cb) {
+                this.addEventListener(eventNameToWrap,
+                    this['_on' + eventNameToWrap] = cb);
+            }
+        }
+    });
+}
+
+// Utility methods.
+module.exports = {
+    extractVersion: extractVersion,
+    wrapPeerConnectionEvent: wrapPeerConnectionEvent,
+    disableLog: function(bool) {
+        if (typeof bool !== 'boolean') {
+            return new Error('Argument type: ' + typeof bool +
+                '. Please use a boolean.');
+        }
+        logDisabled_ = bool;
+        return (bool) ? 'adapter.js logging disabled' :
+            'adapter.js logging enabled';
+    },
+
+    /**
+     * Disable or enable deprecation warnings
+     * @param {!boolean} bool set to true to disable warnings.
+     */
+    disableWarnings: function(bool) {
+        if (typeof bool !== 'boolean') {
+            return new Error('Argument type: ' + typeof bool +
+                '. Please use a boolean.');
+        }
+        deprecationWarnings_ = !bool;
+        return 'adapter.js deprecation warnings ' + (bool ? 'disabled' : 'enabled');
+    },
+
+    log: function() {
+        if (typeof window === 'object') {
+            if (logDisabled_) {
+                return;
+            }
+            if (typeof console !== 'undefined' && typeof console.log === 'function') {
+                console.log.apply(console, arguments);
+            }
+        }
+    },
+
+    /**
+     * Shows a deprecation warning suggesting the modern and spec-compatible API.
+     */
+    deprecated: function(oldMethod, newMethod) {
+        if (!deprecationWarnings_) {
+            return;
+        }
+        console.warn(oldMethod + ' is deprecated, please use ' + newMethod +
+            ' instead.');
+    },
+
+    /**
+     * Browser detector.
+     *
+     * @return {object} result containing browser and version
+     *     properties.
+     */
+    detectBrowser: function(window) {
+        var navigator = window && window.navigator;
+
+        // Returned result object.
+        var result = {};
+        result.browser = null;
+        result.version = null;
+
+        // Fail early if it's not a browser
+        if (typeof window === 'undefined' || !window.navigator) {
+            result.browser = 'Not a browser.';
+            return result;
+        }
+
+        if (navigator.mozGetUserMedia) { // Firefox.
+            result.browser = 'firefox';
+            result.version = extractVersion(navigator.userAgent,
+                /Firefox\/(\d+)\./, 1);
+        } else if (navigator.webkitGetUserMedia) {
+            // Chrome, Chromium, Webview, Opera.
+            // Version matches Chrome/WebRTC version.
+            result.browser = 'chrome';
+            result.version = extractVersion(navigator.userAgent,
+                /Chrom(e|ium)\/(\d+)\./, 2);
+        } else if (navigator.mediaDevices &&
+            navigator.userAgent.match(/Edge\/(\d+).(\d+)$/)) { // Edge.
+            result.browser = 'edge';
+            result.version = extractVersion(navigator.userAgent,
+                /Edge\/(\d+).(\d+)$/, 2);
+        } else if (window.RTCPeerConnection &&
+            navigator.userAgent.match(/AppleWebKit\/(\d+)\./)) { // Safari.
+            result.browser = 'safari';
+            result.version = extractVersion(navigator.userAgent,
+                /AppleWebKit\/(\d+)\./, 1);
+        } else { // Default fallthrough: not supported.
+            result.browser = 'Not a supported browser.';
+            return result;
+        }
+
+        return result;
+    }
+};
+
+},{}]},{},[3])(3)
+});
index cb6c2fe..26cc890 100644 (file)
@@ -1684,8 +1684,8 @@ class core_plugin_manager {
                 'backcolor', 'bold', 'charmap', 'clear', 'collapse', 'emoticon',
                 'equation', 'fontcolor', 'html', 'image', 'indent', 'italic',
                 'link', 'managefiles', 'media', 'noautolink', 'orderedlist',
-                'rtl', 'strike', 'subscript', 'superscript', 'table', 'title',
-                'underline', 'undo', 'unorderedlist'
+                'recordrtc', 'rtl', 'strike', 'subscript', 'superscript', 'table',
+                'title', 'underline', 'undo', 'unorderedlist'
             ),
 
             'assignment' => array(
index 283a09f..662d604 100644 (file)
@@ -41,5 +41,30 @@ function xmldb_editor_atto_upgrade($oldversion) {
     // Automatically generated Moodle v3.4.0 release upgrade line.
     // Put any upgrade step following this.
 
+    if ($oldversion < 2018041100) {
+        $toolbar = get_config('editor_atto', 'toolbar');
+
+        if (strpos($toolbar, 'recordrtc') === false) {
+            $glue = "\r\n";
+            if (strpos($toolbar, $glue) === false) {
+                $glue = "\n";
+            }
+            $groups = explode($glue, $toolbar);
+            // Try to put recordrtc in files group.
+            foreach ($groups as $i => $group) {
+                $parts = explode('=', $group);
+                if (trim($parts[0]) == 'files') {
+                    $groups[$i] = 'files = ' . trim($parts[1]) . ', recordrtc';
+                    // Update config variable.
+                    $toolbar = implode($glue, $groups);
+                    set_config('toolbar', $toolbar, 'editor_atto');
+                }
+            }
+        }
+
+        // Atto editor savepoint reached.
+        upgrade_plugin_savepoint(true, 2018041100, 'editor', 'atto');
+    }
+
     return true;
 }
diff --git a/lib/editor/atto/plugins/recordrtc/classes/privacy/provider.php b/lib/editor/atto/plugins/recordrtc/classes/privacy/provider.php
new file mode 100644 (file)
index 0000000..07aafd2
--- /dev/null
@@ -0,0 +1,46 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle 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, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle 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 Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Privacy Subsystem implementation for atto_recordrtc.
+ *
+ * @package    atto_recordrtc
+ * @copyright  2018 Mark Nelson <markn@moodle.com>
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+namespace atto_recordrtc\privacy;
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Privacy Subsystem for atto_recordrtc implementing null_provider.
+ *
+ * @copyright  2018 Mark Nelson <markn@moodle.com>
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class provider implements \core_privacy\local\metadata\null_provider {
+
+    /**
+     * Get the language string identifier with the component's language
+     * file to explain why this plugin stores no data.
+     *
+     * @return string
+     */
+    public static function get_reason() : string {
+        return 'privacy:metadata';
+    }
+}
diff --git a/lib/editor/atto/plugins/recordrtc/lang/en/atto_recordrtc.php b/lib/editor/atto/plugins/recordrtc/lang/en/atto_recordrtc.php
new file mode 100755 (executable)
index 0000000..7477b24
--- /dev/null
@@ -0,0 +1,75 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle 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, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle 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 Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Strings for component 'atto_recordrtc', language 'en'.
+ *
+ * @package    atto_recordrtc
+ * @author     Jesus Federico (jesus [at] blindsidenetworks [dt] com)
+ * @author     Jacob Prud'homme (jacob [dt] prudhomme [at] blindsidenetworks [dt] com)
+ * @copyright  2017 Blindside Networks Inc.
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+$string['allowedtypes'] = 'Allowed types';
+$string['allowedtypes_desc'] = 'Which recording buttons should appear in Atto';
+$string['attachrecording'] = 'Attach recording';
+$string['audioandvideo'] = 'Audio and video';
+$string['audiobitrate'] = 'Audio bitrate';
+$string['audiobitrate_desc'] = 'Quality of audio recording (larger number means higher quality)';
+$string['audiortc'] = 'Insert audio recording';
+$string['gumabort'] = 'Something strange happened which prevented the webcam/microphone from being used';
+$string['gumabort_title'] = 'Something happened';
+$string['gumnotallowed'] = 'The user must allow the browser access to the webcam/microphone';
+$string['gumnotallowed_title'] = 'Wrong permissions';
+$string['gumnotfound'] = 'There is no input device connected or enabled';
+$string['gumnotfound_title'] = 'Device missing';
+$string['gumnotreadable'] = 'Something is preventing the browser from accessing the webcam/microphone';
+$string['gumnotreadable_title'] = 'Hardware error';
+$string['gumnotsupported'] = 'Your browser does not support recording over an insecure connection and must close the plugin';
+$string['gumnotsupported_title'] = 'No support for insecure connection';
+$string['gumoverconstrained'] = 'The current webcam/microphone can not produce a stream with the required constraints';
+$string['gumoverconstrained_title'] = 'Problem with constraints';
+$string['gumsecurity'] = 'Your browser does not support recording over an insecure connection and must close the plugin';
+$string['gumsecurity_title'] = 'No support for insecure connection';
+$string['gumtype'] = 'Tried to get stream from the webcam/microphone, but no constraints were specified';
+$string['gumtype_title'] = 'No constraints specified';
+$string['insecurealert'] = 'Your browser might not allow this plugin to work unless it is used either over HTTPS or from localhost';
+$string['insecurealert_title'] = 'Insecure connection!';
+$string['nearingmaxsize'] = 'You have attained the maximum size limit for file uploads';
+$string['nearingmaxsize_title'] = 'Recording stopped';
+$string['norecordingfound'] = 'Something appears to have gone wrong, it seems nothing has been recorded';
+$string['norecordingfound_title'] = 'No recording found';
+$string['nowebrtc'] = 'Your browser offers limited or no support for WebRTC technologies yet, and cannot be used with this plugin. Please switch or upgrade your browser';
+$string['nowebrtc_title'] = 'WebRTC not supported';
+$string['onlyaudio'] = 'Audio only';
+$string['onlyvideo'] = 'Video only';
+$string['pluginname'] = 'RecordRTC';
+$string['privacy:metadata'] = 'The RecordRTC plugin does not store any personal data.';
+$string['recordagain'] = 'Record again';
+$string['recordingfailed'] = 'Recording failed, try again';
+$string['settings'] = 'RecordRTC settings';
+$string['startrecording'] = 'Start recording';
+$string['stoprecording'] = 'Stop recording';
+$string['timelimit'] = 'Time limit in seconds';
+$string['timelimit_desc'] = 'Maximum recording length allowed for the audio/video clips';
+$string['uploadaborted'] = 'Upload aborted:';
+$string['uploadfailed'] = 'Upload failed:';
+$string['uploadfailed404'] = 'Upload failed: file too large';
+$string['uploadprogress'] = 'completed';
+$string['videobitrate'] = 'Video bitrate';
+$string['videobitrate_desc'] = 'Quality of video recording (larger number means higher quality)';
+$string['videortc'] = 'Insert video recording';
diff --git a/lib/editor/atto/plugins/recordrtc/lib.php b/lib/editor/atto/plugins/recordrtc/lib.php
new file mode 100644 (file)
index 0000000..d860e85
--- /dev/null
@@ -0,0 +1,119 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle 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, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle 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 Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Atto recordrtc library functions
+ *
+ * @package    atto_recordrtc
+ * @author     Jesus Federico (jesus [at] blindsidenetworks [dt] com)
+ * @author     Jacob Prud'homme (jacob [dt] prudhomme [at] blindsidenetworks [dt] com)
+ * @copyright  2017 Blindside Networks Inc.
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+defined('MOODLE_INTERNAL') || die();
+
+/**
+ * Set params for this plugin.
+ *
+ * @param string $elementid
+ * @param stdClass $options - the options for the editor, including the context.
+ * @param stdClass $fpoptions - unused.
+ */
+function atto_recordrtc_params_for_js($elementid, $options, $fpoptions) {
+    global $CFG;
+
+    $context = $options['context'];
+    if (!$context) {
+        $context = context_system::instance();
+    }
+    $sesskey = sesskey();
+    $allowedtypes = get_config('atto_recordrtc', 'allowedtypes');
+    $audiobitrate = get_config('atto_recordrtc', 'audiobitrate');
+    $videobitrate = get_config('atto_recordrtc', 'videobitrate');
+    $timelimit = get_config('atto_recordrtc', 'timelimit');
+    $maxrecsize = ini_get('upload_max_filesize');
+    $audiortcicon = 'i/audiortc';
+    $videortcicon = 'i/videortc';
+    $params = array('contextid' => $context->id,
+                    'sesskey' => $sesskey,
+                    'allowedtypes' => $allowedtypes,
+                    'audiobitrate' => $audiobitrate,
+                    'videobitrate' => $videobitrate,
+                    'timelimit' => $timelimit,
+                    'audiortcicon' => $audiortcicon,
+                    'videortcicon' => $videortcicon,
+                    'maxrecsize' => $maxrecsize
+              );
+
+    return $params;
+}
+
+/**
+ * Initialise the js strings required for this module.
+ */
+function atto_recordrtc_strings_for_js() {
+    global $PAGE;
+
+    $strings = array('audiortc',
+                     'videortc',
+                     'nowebrtc_title',
+                     'nowebrtc',
+                     'gumabort_title',
+                     'gumabort',
+                     'gumnotallowed_title',
+                     'gumnotallowed',
+                     'gumnotfound_title',
+                     'gumnotfound',
+                     'gumnotreadable_title',
+                     'gumnotreadable',
+                     'gumnotsupported',
+                     'gumnotsupported_title',
+                     'gumoverconstrained_title',
+                     'gumoverconstrained',
+                     'gumsecurity_title',
+                     'gumsecurity',
+                     'gumtype_title',
+                     'gumtype',
+                     'insecurealert_title',
+                     'insecurealert',
+                     'startrecording',
+                     'recordagain',
+                     'stoprecording',
+                     'recordingfailed',
+                     'attachrecording',
+                     'norecordingfound_title',
+                     'norecordingfound',
+                     'nearingmaxsize_title',
+                     'nearingmaxsize',
+                     'uploadprogress',
+                     'uploadfailed',
+                     'uploadfailed404',
+                     'uploadaborted'
+               );
+
+    $PAGE->requires->strings_for_js($strings, 'atto_recordrtc');
+}
+
+/**
+ * Map icons for font-awesome themes.
+ */
+function atto_recordrtc_get_fontawesome_icon_map() {
+    return [
+        'atto_recordrtc:i/audiortc' => 'fa-file-audio-o',
+        'atto_recordrtc:i/videortc' => 'fa-file-video-o'
+    ];
+}
diff --git a/lib/editor/atto/plugins/recordrtc/pix/i/audiortc.png b/lib/editor/atto/plugins/recordrtc/pix/i/audiortc.png
new file mode 100644 (file)
index 0000000..974d7b9
Binary files /dev/null and b/lib/editor/atto/plugins/recordrtc/pix/i/audiortc.png differ
diff --git a/lib/editor/atto/plugins/recordrtc/pix/i/videortc.png b/lib/editor/atto/plugins/recordrtc/pix/i/videortc.png
new file mode 100644 (file)
index 0000000..4829178
Binary files /dev/null and b/lib/editor/atto/plugins/recordrtc/pix/i/videortc.png differ
diff --git a/lib/editor/atto/plugins/recordrtc/pix/icon.png b/lib/editor/atto/plugins/recordrtc/pix/icon.png
new file mode 100644 (file)
index 0000000..8f36cef
Binary files /dev/null and b/lib/editor/atto/plugins/recordrtc/pix/icon.png differ
diff --git a/lib/editor/atto/plugins/recordrtc/settings.php b/lib/editor/atto/plugins/recordrtc/settings.php
new file mode 100644 (file)
index 0000000..92a84d3
--- /dev/null
@@ -0,0 +1,64 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle 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, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle 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 Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Settings that allow turning on and off recordrtc features
+ *
+ * @package    atto_recordrtc
+ * @author     Jesus Federico (jesus [at] blindsidenetworks [dt] com)
+ * @author     Jacob Prud'homme (jacob [dt] prudhomme [at] blindsidenetworks [dt] com)
+ * @copyright  2017 Blindside Networks Inc.
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+defined('MOODLE_INTERNAL') || die();
+
+$ADMIN->add('editoratto', new admin_category('atto_recordrtc', new lang_string('pluginname', 'atto_recordrtc')));
+
+if ($ADMIN->fulltree) {
+    // Types allowed.
+    $options = array(
+        'both' => new lang_string('audioandvideo', 'atto_recordrtc'),
+        'audio' => new lang_string('onlyaudio', 'atto_recordrtc'),
+        'video' => new lang_string('onlyvideo', 'atto_recordrtc')
+    );
+    $name = get_string('allowedtypes', 'atto_recordrtc');
+    $desc = get_string('allowedtypes_desc', 'atto_recordrtc');
+    $default = 'both';
+    $setting = new admin_setting_configselect('atto_recordrtc/allowedtypes', $name, $desc, $default, $options);
+    $settings->add($setting);
+
+    // Audio bitrate.
+    $name = get_string('audiobitrate', 'atto_recordrtc');
+    $desc = get_string('audiobitrate_desc', 'atto_recordrtc');
+    $default = '128000';
+    $setting = new admin_setting_configtext('atto_recordrtc/audiobitrate', $name, $desc, $default, PARAM_INT, 8);
+    $settings->add($setting);
+
+    // Video bitrate.
+    $name = get_string('videobitrate', 'atto_recordrtc');
+    $desc = get_string('videobitrate_desc', 'atto_recordrtc');
+    $default = '2500000';
+    $setting = new admin_setting_configtext('atto_recordrtc/videobitrate', $name, $desc, $default, PARAM_INT, 8);
+    $settings->add($setting);
+
+    // Recording time limit.
+    $name = get_string('timelimit', 'atto_recordrtc');
+    $desc = get_string('timelimit_desc', 'atto_recordrtc');
+    $default = '120';
+    $setting = new admin_setting_configtext('atto_recordrtc/timelimit', $name, $desc, $default, PARAM_INT, 8);
+    $settings->add($setting);
+}
diff --git a/lib/editor/atto/plugins/recordrtc/styles.css b/lib/editor/atto/plugins/recordrtc/styles.css
new file mode 100644 (file)
index 0000000..202e0eb
--- /dev/null
@@ -0,0 +1,39 @@
+.atto_recordrtc,
+.atto_recordrtc div {
+    font-weight: normal;
+    line-height: 40px;
+    padding: 3px 0 3px 0;
+}
+
+.atto_recordrtc .alert {
+    line-height: 40px;
+    text-align: center;
+}
+
+.atto_recordrtc audio {
+    display: block;
+    width: 100%;
+}
+
+@media screen and (max-width: 670px) {
+    .atto_recordrtc video {
+        display: block;
+        height: auto;
+        margin: 0 auto;
+        width: 100%;
+    }
+}
+
+@media screen and (min-width: 671px) {
+    .atto_recordrtc video {
+        display: block;
+        height: 480px;
+        margin: 0 auto;
+        width: 640px;
+    }
+}
+
+.atto_recordrtc #start-stop,
+.atto_recordrtc #upload {
+    white-space: normal;
+}
diff --git a/lib/editor/atto/plugins/recordrtc/version.php b/lib/editor/atto/plugins/recordrtc/version.php
new file mode 100644 (file)
index 0000000..f2d378c
--- /dev/null
@@ -0,0 +1,32 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle 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, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle 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 Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Atto text editor recordrtc version file.
+ *
+ * @package    atto_recordrtc
+ * @author     Jesus Federico (jesus [at] blindsidenetworks [dt] com)
+ * @author     Jacob Prud'homme (jacob [dt] prudhomme [at] blindsidenetworks [dt] com)
+ * @copyright  2017 Blindside Networks Inc.
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+defined('MOODLE_INTERNAL') || die();
+
+$plugin->version   = 2018031500;
+$plugin->requires  = 2018022800;
+$plugin->component = 'atto_recordrtc';
+$plugin->maturity = MATURITY_STABLE;
diff --git a/lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-button/moodle-atto_recordrtc-button-debug.js b/lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-button/moodle-atto_recordrtc-button-debug.js
new file mode 100644 (file)
index 0000000..12bcf30
Binary files /dev/null and b/lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-button/moodle-atto_recordrtc-button-debug.js differ
diff --git a/lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-button/moodle-atto_recordrtc-button-min.js b/lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-button/moodle-atto_recordrtc-button-min.js
new file mode 100644 (file)
index 0000000..5a5a731
Binary files /dev/null and b/lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-button/moodle-atto_recordrtc-button-min.js differ
diff --git a/lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-button/moodle-atto_recordrtc-button.js b/lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-button/moodle-atto_recordrtc-button.js
new file mode 100644 (file)
index 0000000..12bcf30
Binary files /dev/null and b/lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-button/moodle-atto_recordrtc-button.js differ
diff --git a/lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-recording/moodle-atto_recordrtc-recording-debug.js b/lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-recording/moodle-atto_recordrtc-recording-debug.js
new file mode 100644 (file)
index 0000000..fedd668
Binary files /dev/null and b/lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-recording/moodle-atto_recordrtc-recording-debug.js differ
diff --git a/lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-recording/moodle-atto_recordrtc-recording-min.js b/lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-recording/moodle-atto_recordrtc-recording-min.js
new file mode 100644 (file)
index 0000000..4208609
Binary files /dev/null and b/lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-recording/moodle-atto_recordrtc-recording-min.js differ
diff --git a/lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-recording/moodle-atto_recordrtc-recording.js b/lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-recording/moodle-atto_recordrtc-recording.js
new file mode 100644 (file)
index 0000000..fedd668
Binary files /dev/null and b/lib/editor/atto/plugins/recordrtc/yui/build/moodle-atto_recordrtc-recording/moodle-atto_recordrtc-recording.js differ
diff --git a/lib/editor/atto/plugins/recordrtc/yui/src/button/build.json b/lib/editor/atto/plugins/recordrtc/yui/src/button/build.json
new file mode 100755 (executable)
index 0000000..d6abd5d
--- /dev/null
@@ -0,0 +1,10 @@
+{
+  "name": "moodle-atto_recordrtc-button",
+  "builds": {
+    "moodle-atto_recordrtc-button": {
+      "jsfiles": [
+        "button.js"
+      ]
+    }
+  }
+}
diff --git a/lib/editor/atto/plugins/recordrtc/yui/src/button/js/button.js b/lib/editor/atto/plugins/recordrtc/yui/src/button/js/button.js
new file mode 100755 (executable)
index 0000000..37c172a
--- /dev/null
@@ -0,0 +1,349 @@
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle 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, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle 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 Moodle.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+/**
+ * Atto recordrtc library functions
+ *
+ * @package    atto_recordrtc
+ * @author     Jesus Federico (jesus [at] blindsidenetworks [dt] com)
+ * @author     Jacob Prud'homme (jacob [dt] prudhomme [at] blindsidenetworks [dt] com)
+ * @copyright  2017 Blindside Networks Inc.
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+/**
+ * @module moodle-atto_recordrtc-button
+ */
+
+/**
+ * Atto text editor recordrtc plugin.
+ *
+ * @namespace M.atto_recordrtc
+ * @class button
+ * @extends M.editor_atto.EditorPlugin
+ */
+
+// ESLint directives.
+/* eslint-disable camelcase, spaced-comment */
+
+// JSHint directives.
+/*global M */
+/*jshint onevar: false */
+
+// Scrutinizer CI directives.
+/** global: Y */
+/** global: M */
+
+var PLUGINNAME = 'atto_recordrtc',
+    TEMPLATE = '' +
+    '<div class="{{PLUGINNAME}} container-fluid">' +
+      '<div class="{{bs_row}} hide">' +
+        '<div class="{{bs_col}}12">' +
+          '<div id="alert-danger" class="alert {{bs_al_dang}}">' +
+            '<strong>{{insecurealert_title}}</strong> {{insecurealert}}' +
+          '</div>' +
+        '</div>' +
+      '</div>' +
+      '<div class="{{bs_row}} hide">' +
+        '{{#if isAudio}}' +
+          '<div class="{{bs_col}}1"></div>' +
+          '<div class="{{bs_col}}10">' +
+            '<audio id="player"></audio>' +
+          '</div>' +
+          '<div class="{{bs_col}}1"></div>' +
+        '{{else}}' +
+          '<div class="{{bs_col}}12">' +
+            '<video id="player"></video>' +
+          '</div>' +
+        '{{/if}}' +
+      '</div>' +
+      '<div class="{{bs_row}}">' +
+        '<div class="{{bs_col}}1"></div>' +
+        '<div class="{{bs_col}}10">' +
+          '<button id="start-stop" class="{{bs_ss_btn}}">{{startrecording}}</button>' +
+        '</div>' +
+        '<div class="{{bs_col}}1"></div>' +
+      '</div>' +
+      '<div class="{{bs_row}} hide">' +
+        '<div class="{{bs_col}}3"></div>' +
+        '<div class="{{bs_col}}6">' +
+          '<button id="upload" class="btn btn-primary btn-block">{{attachrecording}}</button>' +
+        '</div>' +
+        '<div class="{{bs_col}}3"></div>' +
+      '</div>' +
+    '</div>';
+
+Y.namespace('M.atto_recordrtc').Button = Y.Base.create('button', Y.M.editor_atto.EditorPlugin, [], {
+    /**
+     * The current language by default.
+     */
+    _lang: 'en',
+
+    initializer: function() {
+        if (this.get('host').canShowFilepicker('media')) {
+            // Add audio and/or video buttons depending on the settings.
+            var allowedtypes = this.get('allowedtypes');
+            if (allowedtypes === 'both' || allowedtypes === 'audio') {
+                this._addButton('audio', this._audio);
+            }
+            if (allowedtypes === 'both' || allowedtypes === 'video') {
+                this._addButton('video', this._video);
+            }
+
+            // Initialize the dialogue box.
+            var dialogue = this.getDialogue({
+                width: 1000,
+                focusAfterHide: null
+            });
+
+            // If dialogue is closed during recording, do the following.
+            dialogue.after('visibleChange', function() {
+                var closed = !dialogue.get('visible'),
+                    m = M.atto_recordrtc.commonmodule;
+
+                if (closed) {
+                    window.clearInterval(m.countdownTicker);
+
+                    if (m.mediaRecorder && m.mediaRecorder.state !== 'inactive') {
+                        m.mediaRecorder.stop();
+                    }
+
+                    if (m.stream) {
+                        m.stream.getTracks().forEach(function(track) {
+                            if (track.readyState !== 'ended') {
+                                track.stop();
+                            }
+                        });
+                    }
+                }
+
+            });
+
+            dialogue.on('click', function() {
+                this.centered();
+            });
+
+            // Require adapter.js library.
+            window.require(['core/adapter'], function(adapter) {
+                window.adapter = adapter;
+            });
+        }
+    },
+
+    /**
+     * Add the buttons to the Atto toolbar.
+     *
+     * @method _addButton
+     * @param {string} type
+     * @param {callback} callback
+     * @private
+     */
+    _addButton: function(type, callback) {
+        this.addButton({
+            buttonName: type,
+            icon: this.get(type + 'rtcicon'),
+            iconComponent: PLUGINNAME,
+            callback: callback,
+            title: type + 'rtc',
+            tags: type + 'rtc',
+            tagMatchRequiresAll: false
+        });
+    },
+
+    /**
+     * Toggle audiortc and normal display mode
+     *
+     * @method _audio
+     * @private
+     */
+    _audio: function() {
+        var dialogue = this.getDialogue();
+
+        dialogue.set('headerContent', M.util.get_string('audiortc', 'atto_recordrtc'));
+        dialogue.set('bodyContent', this._createContent('audio'));
+
+        dialogue.show();
+
+        M.atto_recordrtc.audiomodule.init(this);
+    },
+
+    /**
+     * Toggle videortc and normal display mode
+     *
+     * @method _video
+     * @private
+     */
+    _video: function() {
+        var dialogue = this.getDialogue();
+
+        dialogue.set('headerContent', M.util.get_string('videortc', 'atto_recordrtc'));
+        dialogue.set('bodyContent', this._createContent('video'));
+
+        dialogue.show();
+
+        M.atto_recordrtc.videomodule.init(this);
+    },
+
+    /**
+     * Create the HTML to be displayed in the dialogue box
+     *
+     * @method _createContent
+     * @param {string} type
+     * @returns {Object}
+     * @private
+     */
+    _createContent: function(type) {
+        var isAudio = (type === 'audio'),
+            bsRow = 'row',
+            bsCol = 'col-xs-',
+            bsAlDang = 'alert-danger',
+            bsSsBtn = 'btn btn-lg btn-outline-danger btn-block';
+
+        var bodyContent = Y.Handlebars.compile(TEMPLATE)({
+            PLUGINNAME: PLUGINNAME,
+            isAudio: isAudio,
+            bs_row: bsRow,
+            bs_col: bsCol,
+            bs_al_dang: bsAlDang,
+            bs_ss_btn: bsSsBtn,
+            insecurealert_title: M.util.get_string('insecurealert_title', 'atto_recordrtc'),
+            insecurealert: M.util.get_string('insecurealert', 'atto_recordrtc'),
+            startrecording: M.util.get_string('startrecording', 'atto_recordrtc'),
+            attachrecording: M.util.get_string('attachrecording', 'atto_recordrtc')
+        });
+
+        return bodyContent;
+    },
+
+    /**
+     * Close the dialogue without further action.
+     *
+     * @method closeDialogue
+     * @param {Object} scope The "this" context of the editor.
+     */
+    closeDialogue: function(scope) {
+        scope.getDialogue().hide();
+
+        scope.editor.focus();
+    },
+
+    /**
+     * Insert the annotation link in the editor.
+     *
+     * @method setLink
+     * @param {Object} scope The "this" context of the editor.
+     * @param {string} annotation The HTML link to the recording.
+     */
+    setLink: function(scope, annotation) {
+        scope.getDialogue().hide();
+
+        scope.editor.focus();
+        scope.get('host').insertContentAtFocusPoint(annotation);
+        scope.markUpdated();
+    }
+}, {
+    ATTRS: {
+        /**
+         * The contextid to use when generating this recordrtc.
+         *
+         * @attribute contextid
+         * @type String
+         */
+        contextid: {
+            value: null
+        },
+
+        /**
+         * The sesskey to use when generating this recordrtc.
+         *
+         * @attribute sesskey
+         * @type String
+         */
+        sesskey: {
+            value: null
+        },
+
+        /**
+         * The allowedtypes to use when generating this recordrtc.
+         *
+         * @attribute allowedtypes
+         * @type String
+         */
+        allowedtypes: {
+            value: null
+        },
+
+        /**
+         * The audiobitrate to use when generating this recordrtc.
+         *
+         * @attribute audiobitrate
+         * @type String
+         */
+        audiobitrate: {
+            value: null
+        },
+
+        /**
+         * The videobitrate to use when generating this recordrtc.
+         *
+         * @attribute videobitrate
+         * @type String
+         */
+        videobitrate: {
+            value: null
+        },
+
+        /**
+         * The timelimit to use when generating this recordrtc.
+         *
+         * @attribute timelimit
+         * @type String
+         */
+        timelimit: {
+            value: null
+        },
+
+        /**
+         * The audiortcicon to use when generating this recordrtc.
+         *
+         * @attribute audiortcicon
+         * @type String
+         */
+        audiortcicon: {
+            value: null
+        },
+
+        /**
+         * The videortcicon to use when generating this recordrtc.
+         *
+         * @attribute videortcicon
+         * @type String
+         */
+        videortcicon: {
+            value: null
+        },
+
+        /**
+         * Maximum upload size set on server, in MB.
+         *
+         * @attribute maxrecsize
+         * @type String
+         */
+        maxrecsize: {
+            value: null
+        }
+    }
+});
diff --git a/lib/editor/atto/plugins/recordrtc/yui/src/button/meta/button.json b/lib/editor/atto/plugins/recordrtc/yui/src/button/meta/button.json
new file mode 100644 (file)
index 0000000..3aa4826
--- /dev/null
@@ -0,0 +1,8 @@
+{
+    "moodle-atto_recordrtc-button": {
+        "requires": [
+            "moodle-editor_atto-plugin",
+            "moodle-atto_recordrtc-recording"
+        ]
+    }
+}
diff --git a/lib/editor/atto/plugins/recordrtc/yui/src/recording/build.json b/lib/editor/atto/plugins/recordrtc/yui/src/recording/build.json
new file mode 100644 (file)
index 0000000..8fbac69
--- /dev/null
@@ -0,0 +1,14 @@
+{
+    "name": "moodle-atto_recordrtc-recording",
+    "builds": {
+        "moodle-atto_recordrtc-recording": {
+            "jsfiles": [
+                "commonmodule.js",
+                "compatcheckmodule.js",
+                "abstractmodule.js",
+                "audiomodule.js",
+                "videomodule.js"
+            ]
+        }
+    }
+}
diff --git a/lib/editor/atto/plugins/recordrtc/yui/src/recording/js/abstractmodule.js b/lib/editor/atto/plugins/recordrtc/yui/src/recording/js/abstractmodule.js
new file mode 100644 (file)
index 0000000..a90fa2a
--- /dev/null
@@ -0,0 +1,111 @@
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle 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, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle 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 Moodle.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+/**
+ * Atto recordrtc library functions for function abstractions
+ *
+ * @package    atto_recordrtc
+ * @author     Jesus Federico (jesus [at] blindsidenetworks [dt] com)
+ * @author     Jacob Prud'homme (jacob [dt] prudhomme [at] blindsidenetworks [dt] com)
+ * @copyright  2017 Blindside Networks Inc.
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+// ESLint directives.
+/* eslint-disable camelcase */
+
+// Scrutinizer CI directives.
+/** global: M */
+/** global: Y */
+
+M.atto_recordrtc = M.atto_recordrtc || {};
+
+// Shorten access to module namespaces.
+var cm = M.atto_recordrtc.commonmodule,
+    am = M.atto_recordrtc.abstractmodule;
+
+M.atto_recordrtc.abstractmodule = {
+    // A helper for making a Moodle alert appear.
+    // Subject is the content of the alert (which error ther alert is for).
+    // Possibility to add on-alert-close event.
+    show_alert: function(subject, onCloseEvent) {
+        Y.use('moodle-core-notification-alert', function() {
+            var dialogue = new M.core.alert({
+                title: M.util.get_string(subject + '_title', 'atto_recordrtc'),
+                message: M.util.get_string(subject, 'atto_recordrtc')
+            });
+
+            if (onCloseEvent) {
+                dialogue.after('complete', onCloseEvent);
+            }
+        });
+    },
+
+    // Handle getUserMedia errors.
+    handle_gum_errors: function(error, commonConfig) {
+        var btnLabel = M.util.get_string('recordingfailed', 'atto_recordrtc'),
+            treatAsStopped = function() {
+                commonConfig.onMediaStopped(btnLabel);
+            };
+
+        // Changes 'CertainError' -> 'gumcertain' to match language string names.
+        var stringName = 'gum' + error.name.replace('Error', '').toLowerCase();
+
+        // After alert, proceed to treat as stopped recording, or close dialogue.
+        if (stringName !== 'gumsecurity') {
+            am.show_alert(stringName, treatAsStopped);
+        } else {
+            am.show_alert(stringName, function() {
+                cm.editorScope.closeDialogue(cm.editorScope);
+            });
+        }
+    },
+
+    // Select best options for the recording codec.
+    select_rec_options: function(recType) {
+        var types, options;
+
+        if (recType === 'audio') {
+            types = [
+                'audio/webm;codecs=opus',
+                'audio/ogg;codecs=opus'
+            ];
+            options = {
+                audioBitsPerSecond: window.parseInt(cm.editorScope.get('audiobitrate'))
+            };
+        } else {
+            types = [
+                'video/webm;codecs=vp9,opus',
+                'video/webm;codecs=h264,opus',
+                'video/webm;codecs=vp8,opus'
+            ];
+            options = {
+                audioBitsPerSecond: window.parseInt(cm.editorScope.get('audiobitrate')),
+                videoBitsPerSecond: window.parseInt(cm.editorScope.get('videobitrate'))
+            };
+        }
+
+        var compatTypes = types.filter(function(type) {
+            return window.MediaRecorder.isTypeSupported(type);
+        });
+
+        if (compatTypes.length !== 0) {
+            options.mimeType = compatTypes[0];
+        }
+
+        return options;
+    }
+};
diff --git a/lib/editor/atto/plugins/recordrtc/yui/src/recording/js/audiomodule.js b/lib/editor/atto/plugins/recordrtc/yui/src/recording/js/audiomodule.js
new file mode 100644 (file)
index 0000000..7c2abc4
--- /dev/null
@@ -0,0 +1,148 @@
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle 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, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle 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 Moodle.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+/**
+ * Atto recordrtc library functions
+ *
+ * @package    atto_recordrtc
+ * @author     Jesus Federico (jesus [at] blindsidenetworks [dt] com)
+ * @author     Jacob Prud'homme (jacob [dt] prudhomme [at] blindsidenetworks [dt] com)
+ * @copyright  2017 Blindside Networks Inc.
+ * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+
+// ESLint directives.
+/* eslint-disable camelcase, spaced-comment */
+
+// Scrutinizer CI directives.
+/** global: M */
+/** global: Y */
+
+M.atto_recordrtc = M.atto_recordrtc || {};
+
+// Shorten access to module namespaces.
+var cm = M.atto_recordrtc.commonmodule,
+    am = M.atto_recordrtc.abstractmodule,
+    ccm = M.atto_recordrtc.compatcheckmodule;
+
+M.atto_recordrtc.audiomodule = {
+    init: function(scope) {
+        // Assignment of global variables.
+        cm.editorScope = scope; // Allows access to the editor's "this" context.
+        cm.alertWarning = Y.one('div#alert-warning');
+        cm.alertDanger = Y.one('div#alert-danger');
+        cm.player = Y.one('audio#player');
+        cm.playerDOM = document.querySelector('audio#player');
+        cm.startStopBtn = Y.one('button#start-stop');
+        cm.uploadBtn = Y.one('button#upload');
+        cm.recType = 'audio';
+        // Extract the numbers from the string, and convert to bytes.
+        cm.maxUploadSize = window.parseInt(scope.get('maxrecsize').match(/\d+/)[0], 10) * Math.pow(1024, 2);
+
+        // Show alert and close plugin if WebRTC is not supported.
+        ccm.check_has_gum();
+        // Show alert and redirect user if connection is not secure.
+        ccm.check_secure();
+
+        // Run when user clicks on "record" button.
+        cm.startStopBtn.on('click', function() {
+            cm.startStopBtn.set('disabled', true);
+
+            // If button is displaying "Start Recording" or "Record Again".
+            if ((cm.startStopBtn.get('textContent') === M.util.get_string('startrecording', 'atto_recordrtc')) ||
+                (cm.startStopBtn.get('textContent') === M.util.get_string('recordagain', 'atto_recordrtc')) ||
+                (cm.startStopBtn.get('textContent') === M.util.get_string('recordingfailed', 'atto_recordrtc'))) {
+                // Make sure the audio player and upload button are not shown.
+                cm.player.ancestor().ancestor().addClass('hide');
+                cm.uploadBtn.ancestor().ancestor().addClass('hide');
+
+                // Change look of recording button.
+                cm.startStopBtn.replaceClass('btn-outline-danger', 'btn-danger');
+
+                // Empty the array containing the previously recorded chunks.
+                cm.chunks = [];
+                cm.blobSize = 0;
+
+                // Initialize common configurations.
+                var commonConfig = {
+                    // When the stream is captured from the microphone/webcam.
+                    onMediaCaptured: function(stream) {
+                        // Make audio stream available at a higher level by making it a property of the common module.
+                        cm.stream = stream;
+
+                        cm.start_recording(cm.recType, cm.stream);
+                    },
+
+                    // Revert button to "Record Again" when recording is stopped.
+                    onMediaStopped: function(btnLabel) {
+                        cm.startStopBtn.set('textContent', btnLabel);
+                        cm.startStopBtn.set('disabled', false);
+                        cm.startStopBtn.replaceClass('btn-danger', 'btn-outline-danger');
+                    },
+
+                    // Handle recording errors.
+                    onMediaCapturingFailed: function(error) {
+                        am.handle_gum_errors(error, commonConfig);
+                    }
+                };
+
+                // Capture audio stream from microphone.
+                M.atto_recordrtc.audiomodule.capture_audio(commonConfig);
+            } else { // If button is displaying "Stop Recording".
+                // First of all clears the countdownTicker.
+                window.clearInterval(cm.countdownTicker);
+
+                // Disable "Record Again" button for 1s to allow background processing (closing streams).
+                window.setTimeout(function() {
+                    cm.startStopBtn.set('disabled', false);
+                }, 1000);
+
+                // Stop recording.
+                cm.stop_recording(cm.stream);
+
+                // Change button to offer to record again.
+                cm.startStopBtn.set('textContent', M.util.get_string('recordagain', 'atto_recordrtc'));
+                cm.startStopBtn.replaceClass('btn-danger', 'btn-outline-danger');
+            }
+
+            // Get dialogue centered.
+            cm.editorScope.getDialogue().centered();
+        });
+    },
+
+    // Setup to get audio stream from microphone.
+    capture_audio: function(config) {
+        cm.capture_user_media(
+            // Media constraints.
+            {
+                audio: true
+            },
+
+            // Success callback.
+            function(audioStream) {
+                // Set audio player source to microphone stream.
+                cm.playerDOM.srcO