diff --git a/.gitignore b/.gitignore
index e92d49a0f2e4..4df5d7991671 100644
--- a/.gitignore
+++ b/.gitignore
@@ -51,6 +51,8 @@ node_modules
 *.scssc
 lms/static/sass/*.css
 lms/static/sass/application.scss
+lms/static/sass/application-extend1.scss
+lms/static/sass/application-extend2.scss
 lms/static/sass/course.scss
 cms/static/sass/*.css
 
diff --git a/AUTHORS b/AUTHORS
index 94963e463041..2f4d7efeadd5 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -89,3 +89,4 @@ Akshay Jagadeesh <akjags@gmail.com>
 Nick Parlante <nick.parlante@cs.stanford.edu>
 Marko Seric <marko.seric@math.uzh.ch>
 Felipe Montoya <felipe.montoya@edunext.co>
+Julia Hansbrough <julia@edx.org>
diff --git a/CHANGELOG.rst b/CHANGELOG.rst
index bd28c47a741d..ff74b9873b55 100644
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@@ -5,7 +5,14 @@ These are notable changes in edx-platform.  This is a rolling list of changes,
 in roughly chronological order, most recent first.  Add your entries at or near
 the top.  Include a label indicating the component affected.
 
-LMS: Add PaidCourseRegistration mode, where payment is required before course registration.
+LMS: Fix issue with CourseMode expiration dates
+
+LMS: Ported bulk emailing to the beta instructor dashboard.
+
+LMS: Add monitoring of bulk email subtasks to display progress on instructor dash.
+
+LMS: Add PaidCourseRegistration mode, where payment is required before course
+registration.
 
 LMS: Add split testing functionality for internal use.
 
diff --git a/cms/djangoapps/contentstore/features/video.feature b/cms/djangoapps/contentstore/features/video.feature
index ad6fea083be2..8f6ca144b861 100644
--- a/cms/djangoapps/contentstore/features/video.feature
+++ b/cms/djangoapps/contentstore/features/video.feature
@@ -2,15 +2,18 @@
 Feature: CMS.Video Component
   As a course author, I want to be able to view my created videos in Studio.
 
+  # 1
   # Video Alpha Features will work in Firefox only when Firefox is the active window
   Scenario: Autoplay is disabled in Studio
     Given I have created a Video component
     Then when I view the video it does not have autoplay enabled
 
+  # 2
   Scenario: Creating a video takes a single click
     Given I have clicked the new unit button
     Then creating a video takes a single click
 
+  # 3
   # Sauce Labs cannot delete cookies
   @skip_sauce
   Scenario: Captions are hidden correctly
@@ -18,12 +21,14 @@ Feature: CMS.Video Component
     And I have hidden captions
     Then when I view the video it does not show the captions
 
+  # 4
   # Sauce Labs cannot delete cookies
   @skip_sauce
   Scenario: Captions are shown correctly
     Given I have created a Video component with subtitles
     Then when I view the video it does show the captions
 
+  # 5
   # Sauce Labs cannot delete cookies
   @skip_sauce
   Scenario: Captions are toggled correctly
@@ -31,6 +36,35 @@ Feature: CMS.Video Component
     And I have toggled captions
     Then when I view the video it does show the captions
 
+  # 6
   Scenario: Video data is shown correctly
     Given I have created a video with only XML data
     Then the correct Youtube video is shown
+
+  # 7
+  Scenario: Closed captions become visible when the mouse hovers over CC button
+    Given I have created a Video component with subtitles
+    And Make sure captions are closed
+    Then Captions become "invisible" after 3 seconds
+    And I hover over button "CC"
+    Then Captions become "visible"
+    And I hover over button "volume"
+    Then Captions become "invisible" after 3 seconds
+
+  # 8
+  Scenario: Open captions never become invisible
+    Given I have created a Video component with subtitles
+    And Make sure captions are open
+    Then Captions are "visible"
+    And I hover over button "CC"
+    Then Captions are "visible"
+    And I hover over button "volume"
+    Then Captions are "visible"
+
+  # 9
+  Scenario: Closed captions are invisible when mouse doesn't hover on CC button
+    Given I have created a Video component with subtitles
+    And Make sure captions are closed
+    Then Captions become "invisible" after 3 seconds
+    And I hover over button "volume"
+    Then Captions are "invisible"
diff --git a/cms/djangoapps/contentstore/features/video.py b/cms/djangoapps/contentstore/features/video.py
index 59c5f2bab9e1..1b422294d0a1 100644
--- a/cms/djangoapps/contentstore/features/video.py
+++ b/cms/djangoapps/contentstore/features/video.py
@@ -5,6 +5,11 @@
 from xmodule.modulestore import Location
 from contentstore.utils import get_modulestore
 
+BUTTONS = {
+    'CC': '.hide-subtitles',
+    'volume': '.volume',
+}
+
 
 @step('I have created a Video component$')
 def i_created_a_video_component(step):
@@ -17,8 +22,13 @@ def i_created_a_video_component(step):
 
 
 @step('I have created a Video component with subtitles$')
-def i_created_a_video_component_subtitles(step):
-    step.given('I have created a Video component')
+def i_created_a_video_with_subs(_step):
+    _step.given('I have created a Video component with subtitles "OEoXaMPEzfM"')
+
+
+@step('I have created a Video component with subtitles "([^"]*)"$')
+def i_created_a_video_with_subs_with_name(_step, sub_id):
+    _step.given('I have created a Video component')
 
     # Store the current URL so we can return here
     video_url = world.browser.url
@@ -108,3 +118,37 @@ def the_youtube_video_is_shown(_step):
     ele = world.css_find('.video').first
     assert ele['data-streams'].split(':')[1] == world.scenario_dict['YOUTUBE_ID']
 
+
+@step('Make sure captions are (.+)$')
+def set_captions_visibility_state(_step, captions_state):
+    if captions_state == 'closed':
+        if world.css_visible('.subtitles'):
+            world.browser.find_by_css('.hide-subtitles').click()
+    else:
+        if not world.css_visible('.subtitles'):
+            world.browser.find_by_css('.hide-subtitles').click()
+
+
+@step('I hover over button "([^"]*)"$')
+def hover_over_button(_step, button):
+    world.css_find(BUTTONS[button.strip()]).mouse_over()
+
+
+@step('Captions (?:are|become) "([^"]*)"$')
+def are_captions_visibile(_step, visibility_state):
+    _step.given('Captions become "{0}" after 0 seconds'.format(visibility_state))
+
+
+@step('Captions (?:are|become) "([^"]*)" after (.+) seconds$')
+def check_captions_visibility_state(_step, visibility_state, timeout):
+    timeout = int(timeout.strip())
+
+    # Captions become invisible by fading out. We must wait by a specified
+    # time.
+    world.wait(timeout)
+
+    if visibility_state == 'visible':
+        assert world.css_visible('.subtitles')
+    else:
+        assert not world.css_visible('.subtitles')
+
diff --git a/cms/envs/common.py b/cms/envs/common.py
index 13faf5520e94..a82ec4ab4157 100644
--- a/cms/envs/common.py
+++ b/cms/envs/common.py
@@ -150,6 +150,7 @@
 
     # Instead of AuthenticationMiddleware, we use a cache-backed version
     'cache_toolbox.middleware.CacheBackedAuthenticationMiddleware',
+    'student.middleware.UserStandingMiddleware',
     'contentserver.middleware.StaticContentServer',
 
     'django.contrib.messages.middleware.MessageMiddleware',
diff --git a/common/djangoapps/course_modes/models.py b/common/djangoapps/course_modes/models.py
index fa1a687e47c6..ce1505964313 100644
--- a/common/djangoapps/course_modes/models.py
+++ b/common/djangoapps/course_modes/models.py
@@ -55,8 +55,8 @@ def modes_for_course(cls, course_id):
         """
         now = datetime.now(pytz.UTC)
         found_course_modes = cls.objects.filter(Q(course_id=course_id) &
-                                                Q(expiration_date__isnull=True) |
-                                                Q(expiration_date__gte=now))
+                                                (Q(expiration_date__isnull=True) |
+                                                Q(expiration_date__gte=now)))
         modes = ([Mode(mode.mode_slug, mode.mode_display_name, mode.min_price, mode.suggested_prices, mode.currency)
                   for mode in found_course_modes])
         if not modes:
diff --git a/common/djangoapps/course_modes/tests/test_models.py b/common/djangoapps/course_modes/tests/test_models.py
index deeed6ea9ba0..651c7c51a56d 100644
--- a/common/djangoapps/course_modes/tests/test_models.py
+++ b/common/djangoapps/course_modes/tests/test_models.py
@@ -102,3 +102,12 @@ def test_modes_for_course_expired(self):
         self.create_mode(mode1.slug, mode1.name, mode1.min_price, mode1.suggested_prices)
         modes = CourseMode.modes_for_course(self.course_id)
         self.assertEqual([mode1], modes)
+
+        expired_mode.expiration_date = datetime.now(pytz.UTC) + timedelta(days=1)
+        expired_mode.save()
+        expired_mode_value = Mode(u'verified', u'Verified Certificate', 0, '', 'usd')
+        modes = CourseMode.modes_for_course(self.course_id)
+        self.assertEqual([expired_mode_value, mode1], modes)
+
+        modes = CourseMode.modes_for_course('second_test_course')
+        self.assertEqual([CourseMode.DEFAULT_MODE], modes)
diff --git a/common/djangoapps/student/middleware.py b/common/djangoapps/student/middleware.py
new file mode 100644
index 000000000000..b4f6ad0686ff
--- /dev/null
+++ b/common/djangoapps/student/middleware.py
@@ -0,0 +1,37 @@
+"""
+Middleware that checks user standing for the purpose of keeping users with
+disabled accounts from accessing the site.
+"""
+from django.http import HttpResponseForbidden
+from django.utils.translation import ugettext as _
+from django.conf import settings
+from student.models import UserStanding
+
+class UserStandingMiddleware(object):
+    """
+    Checks a user's standing on request. Returns a 403 if the user's
+    status is 'disabled'.
+    """
+    def process_request(self, request):
+        user = request.user
+        try:
+            user_account = UserStanding.objects.get(user=user.id)
+            # because user is a unique field in UserStanding, there will either be
+            # one or zero user_accounts associated with a UserStanding
+        except UserStanding.DoesNotExist:
+            pass
+        else:
+            if user_account.account_status == UserStanding.ACCOUNT_DISABLED:
+                msg = _(
+                            'Your account has been disabled. If you believe '
+                            'this was done in error, please contact us at '
+                            '{link_start}{support_email}{link_end}'
+                        ).format(
+                            support_email=settings.DEFAULT_FEEDBACK_EMAIL,
+                            link_start=u'<a href="mailto:{address}?subject={subject_line}">'.format(
+                                address=settings.DEFAULT_FEEDBACK_EMAIL,
+                                subject_line=_('Disabled Account'),
+                            ),
+                            link_end=u'</a>'
+                        )
+                return HttpResponseForbidden(msg)
diff --git a/common/djangoapps/student/migrations/0028_auto__add_userstanding.py b/common/djangoapps/student/migrations/0028_auto__add_userstanding.py
new file mode 100644
index 000000000000..d26699448a08
--- /dev/null
+++ b/common/djangoapps/student/migrations/0028_auto__add_userstanding.py
@@ -0,0 +1,188 @@
+# -*- coding: utf-8 -*-
+import datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Adding model 'UserStanding'
+        db.create_table('student_userstanding', (
+            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
+            ('user', self.gf('django.db.models.fields.related.ForeignKey')(related_name='standing', unique=True, to=orm['auth.User'])),
+            ('account_status', self.gf('django.db.models.fields.CharField')(max_length=31, blank=True)),
+            ('changed_by', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['auth.User'], blank=True)),
+            ('standing_last_changed_at', self.gf('django.db.models.fields.DateTimeField')(auto_now=True, blank=True)),
+        ))
+        db.send_create_signal('student', ['UserStanding'])
+
+
+    def backwards(self, orm):
+        # Deleting model 'UserStanding'
+        db.delete_table('student_userstanding')
+
+
+    models = {
+        'auth.group': {
+            'Meta': {'object_name': 'Group'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
+            'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
+        },
+        'auth.permission': {
+            'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'},
+            'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
+        },
+        'auth.user': {
+            'Meta': {'object_name': 'User'},
+            'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
+            'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
+            'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
+            'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
+        },
+        'contenttypes.contenttype': {
+            'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
+            'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
+        },
+        'student.courseenrollment': {
+            'Meta': {'ordering': "('user', 'course_id')", 'unique_together': "(('user', 'course_id'),)", 'object_name': 'CourseEnrollment'},
+            'course_id': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'null': 'True', 'db_index': 'True', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'mode': ('django.db.models.fields.CharField', [], {'default': "'honor'", 'max_length': '100'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']"})
+        },
+        'student.courseenrollmentallowed': {
+            'Meta': {'unique_together': "(('email', 'course_id'),)", 'object_name': 'CourseEnrollmentAllowed'},
+            'auto_enroll': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'course_id': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'null': 'True', 'db_index': 'True', 'blank': 'True'}),
+            'email': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
+        },
+        'student.pendingemailchange': {
+            'Meta': {'object_name': 'PendingEmailChange'},
+            'activation_key': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '32', 'db_index': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'new_email': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '255', 'blank': 'True'}),
+            'user': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['auth.User']", 'unique': 'True'})
+        },
+        'student.pendingnamechange': {
+            'Meta': {'object_name': 'PendingNameChange'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'new_name': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
+            'rationale': ('django.db.models.fields.CharField', [], {'max_length': '1024', 'blank': 'True'}),
+            'user': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['auth.User']", 'unique': 'True'})
+        },
+        'student.registration': {
+            'Meta': {'object_name': 'Registration', 'db_table': "'auth_registration'"},
+            'activation_key': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '32', 'db_index': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']", 'unique': 'True'})
+        },
+        'student.testcenterregistration': {
+            'Meta': {'object_name': 'TestCenterRegistration'},
+            'accommodation_code': ('django.db.models.fields.CharField', [], {'max_length': '64', 'blank': 'True'}),
+            'accommodation_request': ('django.db.models.fields.CharField', [], {'max_length': '1024', 'blank': 'True'}),
+            'authorization_id': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'db_index': 'True'}),
+            'client_authorization_id': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '20', 'db_index': 'True'}),
+            'confirmed_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'db_index': 'True'}),
+            'course_id': ('django.db.models.fields.CharField', [], {'max_length': '128', 'db_index': 'True'}),
+            'created_at': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'db_index': 'True', 'blank': 'True'}),
+            'eligibility_appointment_date_first': ('django.db.models.fields.DateField', [], {'db_index': 'True'}),
+            'eligibility_appointment_date_last': ('django.db.models.fields.DateField', [], {'db_index': 'True'}),
+            'exam_series_code': ('django.db.models.fields.CharField', [], {'max_length': '15', 'db_index': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'processed_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'db_index': 'True'}),
+            'testcenter_user': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['student.TestCenterUser']"}),
+            'updated_at': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'db_index': 'True', 'blank': 'True'}),
+            'upload_error_message': ('django.db.models.fields.CharField', [], {'max_length': '512', 'blank': 'True'}),
+            'upload_status': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '20', 'blank': 'True'}),
+            'uploaded_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'db_index': 'True'}),
+            'user_updated_at': ('django.db.models.fields.DateTimeField', [], {'db_index': 'True'})
+        },
+        'student.testcenteruser': {
+            'Meta': {'object_name': 'TestCenterUser'},
+            'address_1': ('django.db.models.fields.CharField', [], {'max_length': '40'}),
+            'address_2': ('django.db.models.fields.CharField', [], {'max_length': '40', 'blank': 'True'}),
+            'address_3': ('django.db.models.fields.CharField', [], {'max_length': '40', 'blank': 'True'}),
+            'candidate_id': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'db_index': 'True'}),
+            'city': ('django.db.models.fields.CharField', [], {'max_length': '32', 'db_index': 'True'}),
+            'client_candidate_id': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '50', 'db_index': 'True'}),
+            'company_name': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '50', 'blank': 'True'}),
+            'confirmed_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'db_index': 'True'}),
+            'country': ('django.db.models.fields.CharField', [], {'max_length': '3', 'db_index': 'True'}),
+            'created_at': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'db_index': 'True', 'blank': 'True'}),
+            'extension': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '8', 'blank': 'True'}),
+            'fax': ('django.db.models.fields.CharField', [], {'max_length': '35', 'blank': 'True'}),
+            'fax_country_code': ('django.db.models.fields.CharField', [], {'max_length': '3', 'blank': 'True'}),
+            'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'db_index': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'last_name': ('django.db.models.fields.CharField', [], {'max_length': '50', 'db_index': 'True'}),
+            'middle_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'phone': ('django.db.models.fields.CharField', [], {'max_length': '35'}),
+            'phone_country_code': ('django.db.models.fields.CharField', [], {'max_length': '3', 'db_index': 'True'}),
+            'postal_code': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '16', 'blank': 'True'}),
+            'processed_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'db_index': 'True'}),
+            'salutation': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
+            'state': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '20', 'blank': 'True'}),
+            'suffix': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
+            'updated_at': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'db_index': 'True', 'blank': 'True'}),
+            'upload_error_message': ('django.db.models.fields.CharField', [], {'max_length': '512', 'blank': 'True'}),
+            'upload_status': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '20', 'blank': 'True'}),
+            'uploaded_at': ('django.db.models.fields.DateTimeField', [], {'db_index': 'True', 'null': 'True', 'blank': 'True'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['auth.User']", 'unique': 'True'}),
+            'user_updated_at': ('django.db.models.fields.DateTimeField', [], {'db_index': 'True'})
+        },
+        'student.userprofile': {
+            'Meta': {'object_name': 'UserProfile', 'db_table': "'auth_userprofile'"},
+            'allow_certificate': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'courseware': ('django.db.models.fields.CharField', [], {'default': "'course.xml'", 'max_length': '255', 'blank': 'True'}),
+            'gender': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '6', 'null': 'True', 'blank': 'True'}),
+            'goals': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'language': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '255', 'blank': 'True'}),
+            'level_of_education': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '6', 'null': 'True', 'blank': 'True'}),
+            'location': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '255', 'blank': 'True'}),
+            'mailing_address': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
+            'meta': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '255', 'blank': 'True'}),
+            'user': ('django.db.models.fields.related.OneToOneField', [], {'related_name': "'profile'", 'unique': 'True', 'to': "orm['auth.User']"}),
+            'year_of_birth': ('django.db.models.fields.IntegerField', [], {'db_index': 'True', 'null': 'True', 'blank': 'True'})
+        },
+        'student.userstanding': {
+            'Meta': {'object_name': 'UserStanding'},
+            'account_status': ('django.db.models.fields.CharField', [], {'max_length': '31', 'blank': 'True'}),
+            'changed_by': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']", 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'standing_last_changed_at': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'standing'", 'unique': 'True', 'to': "orm['auth.User']"})
+        },
+        'student.usertestgroup': {
+            'Meta': {'object_name': 'UserTestGroup'},
+            'description': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '32', 'db_index': 'True'}),
+            'users': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.User']", 'db_index': 'True', 'symmetrical': 'False'})
+        }
+    }
+
+    complete_apps = ['student']
\ No newline at end of file
diff --git a/common/djangoapps/student/models.py b/common/djangoapps/student/models.py
index da16a2fda227..78e673df715e 100644
--- a/common/djangoapps/student/models.py
+++ b/common/djangoapps/student/models.py
@@ -33,6 +33,27 @@
 log = logging.getLogger(__name__)
 AUDIT_LOG = logging.getLogger("audit")
 
+class UserStanding(models.Model):
+    """
+    This table contains a student's account's status.
+    Currently, we're only disabling accounts; in the future we can imagine
+    taking away more specific privileges, like forums access, or adding
+    more specific karma levels or probationary stages.
+    """
+    ACCOUNT_DISABLED = "disabled"
+    ACCOUNT_ENABLED = "enabled"
+    USER_STANDING_CHOICES = (
+        (ACCOUNT_DISABLED, u"Account Disabled"),
+        (ACCOUNT_ENABLED, u"Account Enabled"),
+    )
+
+    user = models.ForeignKey(User, db_index=True, related_name='standing', unique=True)
+    account_status = models.CharField(
+        blank=True, max_length=31, choices=USER_STANDING_CHOICES
+    )
+    changed_by = models.ForeignKey(User, blank=True)
+    standing_last_changed_at = models.DateTimeField(auto_now=True)
+
 
 class UserProfile(models.Model):
     """This is where we store all the user demographic fields. We have a
diff --git a/common/djangoapps/student/tests/factories.py b/common/djangoapps/student/tests/factories.py
index 49864fcbd4bb..b2f4d95776e0 100644
--- a/common/djangoapps/student/tests/factories.py
+++ b/common/djangoapps/student/tests/factories.py
@@ -1,6 +1,7 @@
 from student.models import (User, UserProfile, Registration,
                             CourseEnrollmentAllowed, CourseEnrollment,
-                            PendingEmailChange)
+                            PendingEmailChange, UserStanding,
+                            )
 from django.contrib.auth.models import Group
 from datetime import datetime
 from factory import DjangoModelFactory, SubFactory, PostGenerationMethodCall, post_generation, Sequence
@@ -16,6 +17,13 @@ class GroupFactory(DjangoModelFactory):
 
     name = u'staff_MITx/999/Robot_Super_Course'
 
+class UserStandingFactory(DjangoModelFactory):
+    FACTORY_FOR = UserStanding
+
+    user = None
+    account_status = None
+    changed_by = None
+
 
 class UserProfileFactory(DjangoModelFactory):
     FACTORY_FOR = UserProfile
diff --git a/common/djangoapps/student/tests/test_userstanding.py b/common/djangoapps/student/tests/test_userstanding.py
new file mode 100644
index 000000000000..730984c91875
--- /dev/null
+++ b/common/djangoapps/student/tests/test_userstanding.py
@@ -0,0 +1,115 @@
+"""
+These are tests for disabling and enabling student accounts, and for making sure
+that students with disabled accounts are unable to access the courseware.
+"""
+from student.tests.factories import UserFactory, UserStandingFactory
+from student.models import UserStanding
+from django.test import TestCase, Client
+from django.core.urlresolvers import reverse, NoReverseMatch
+from nose.plugins.skip import SkipTest
+
+
+class UserStandingTest(TestCase):
+    """test suite for user standing view for enabling and disabling accounts"""
+
+    def setUp(self):
+        # create users
+        self.bad_user = UserFactory.create(
+            username='bad_user',
+        )
+        self.good_user = UserFactory.create(
+            username='good_user',
+        )
+        self.non_staff = UserFactory.create(
+            username='non_staff',
+        )
+        self.admin = UserFactory.create(
+            username='admin',
+            is_staff=True,
+        )
+
+        # create clients
+        self.bad_user_client = Client()
+        self.good_user_client = Client()
+        self.non_staff_client = Client()
+        self.admin_client = Client()
+
+        for user, client in [
+            (self.bad_user, self.bad_user_client),
+            (self.good_user, self.good_user_client),
+            (self.non_staff, self.non_staff_client),
+            (self.admin, self.admin_client),
+        ]:
+            client.login(username=user.username, password='test')
+
+        UserStandingFactory.create(
+            user=self.bad_user,
+            account_status=UserStanding.ACCOUNT_DISABLED,
+            changed_by=self.admin
+        )
+
+        # set different stock urls for lms and cms
+        # to test disabled accounts' access to site
+        try:
+            self.some_url = reverse('dashboard')
+        except NoReverseMatch:
+            self.some_url = reverse('index')
+
+        # since it's only possible to disable accounts from lms, we're going
+        # to skip tests for cms
+
+    def test_disable_account(self):
+        self.assertEqual(
+            UserStanding.objects.filter(user=self.good_user).count(), 0
+        )
+        try:
+            response = self.admin_client.post(reverse('disable_account_ajax'), {
+                'username': self.good_user.username,
+                'account_action': 'disable',
+            })
+        except NoReverseMatch:
+            raise SkipTest()
+        self.assertEqual(
+            UserStanding.objects.get(user=self.good_user).account_status,
+            UserStanding.ACCOUNT_DISABLED
+        )
+
+    def test_disabled_account_403s(self):
+        response = self.bad_user_client.get(self.some_url)
+        self.assertEqual(response.status_code, 403)
+
+    def test_reenable_account(self):
+        try:
+            response = self.admin_client.post(reverse('disable_account_ajax'), {
+                'username': self.bad_user.username,
+                'account_action': 'reenable'
+            })
+        except NoReverseMatch:
+            raise SkipTest()
+        self.assertEqual(
+            UserStanding.objects.get(user=self.bad_user).account_status,
+            UserStanding.ACCOUNT_ENABLED
+        )
+
+    def test_non_staff_cant_access_disable_view(self):
+        try:
+            response = self.non_staff_client.get(reverse('manage_user_standing'), {
+                'user': self.non_staff,
+            })
+        except NoReverseMatch:
+            raise SkipTest()
+        self.assertEqual(response.status_code, 404)
+
+    def test_non_staff_cant_disable_account(self):
+        try:
+            response = self.non_staff_client.post(reverse('disable_account_ajax'), {
+                'username': self.good_user.username,
+                'user': self.non_staff,
+                'account_action': 'disable'
+            })
+        except NoReverseMatch:
+            raise SkipTest()
+        self.assertEqual(response.status_code, 404)
+        self.assertEqual(
+            UserStanding.objects.filter(user=self.good_user).count(), 0
+        )
diff --git a/common/djangoapps/student/views.py b/common/djangoapps/student/views.py
index db2ce5b4a452..6360f7f2e653 100644
--- a/common/djangoapps/student/views.py
+++ b/common/djangoapps/student/views.py
@@ -16,6 +16,7 @@
 from django.contrib.auth.models import User
 from django.contrib.auth.decorators import login_required
 from django.contrib.auth.views import password_reset_confirm
+# from django.contrib.sessions.models import Session
 from django.core.cache import cache
 from django.core.context_processors import csrf
 from django.core.mail import send_mail
@@ -29,18 +30,21 @@
 from django_future.csrf import ensure_csrf_cookie
 from django.utils.http import cookie_date, base36_to_int, urlencode
 from django.utils.translation import ugettext as _
-from django.views.decorators.http import require_POST
+from django.views.decorators.http import require_POST, require_GET
+from django.contrib.admin.views.decorators import staff_member_required
+from django.utils.translation import ugettext as _u
 
 from ratelimitbackend.exceptions import RateLimitException
 
 from mitxmako.shortcuts import render_to_response, render_to_string
 
 from course_modes.models import CourseMode
-from student.models import (Registration, UserProfile, TestCenterUser, TestCenterUserForm,
-                            TestCenterRegistration, TestCenterRegistrationForm,
-                            PendingNameChange, PendingEmailChange,
-                            CourseEnrollment, unique_id_for_user,
-                            get_testcenter_registration, CourseEnrollmentAllowed)
+from student.models import (
+    Registration, UserProfile, TestCenterUser, TestCenterUserForm,
+    TestCenterRegistration, TestCenterRegistrationForm, PendingNameChange,
+    PendingEmailChange, CourseEnrollment, unique_id_for_user,
+    get_testcenter_registration, CourseEnrollmentAllowed, UserStanding,
+)
 from student.forms import PasswordResetFormNoActive
 
 from certificates.models import CertificateStatuses, certificate_status_for_student
@@ -65,6 +69,8 @@
 from dogapi import dog_stats_api
 from pytz import UTC
 
+from util.json_request import JsonResponse
+
 log = logging.getLogger("mitx.student")
 AUDIT_LOG = logging.getLogger("audit")
 
@@ -597,6 +603,81 @@ def logout_user(request):
                            domain=settings.SESSION_COOKIE_DOMAIN)
     return response
 
+@require_GET
+@login_required
+@ensure_csrf_cookie
+def manage_user_standing(request):
+    """
+    Renders the view used to manage user standing. Also displays a table
+    of user accounts that have been disabled and who disabled them.
+    """
+    if not request.user.is_staff:
+        raise Http404
+    all_disabled_accounts = UserStanding.objects.filter(
+        account_status=UserStanding.ACCOUNT_DISABLED
+    )
+
+    all_disabled_users = [standing.user for standing in all_disabled_accounts]
+
+    headers = ['username', 'account_changed_by']
+    rows = []
+    for user in all_disabled_users:
+        row = [user.username, user.standing.all()[0].changed_by]
+        rows.append(row)
+
+
+    context = {'headers': headers, 'rows': rows}
+
+    return render_to_response("manage_user_standing.html", context)
+
+@require_POST
+@login_required
+@ensure_csrf_cookie
+def disable_account_ajax(request):
+    """
+    Ajax call to change user standing. Endpoint of the form
+    in manage_user_standing.html
+    """
+    if not request.user.is_staff:
+        raise Http404
+    username = request.POST.get('username')
+    context = {}
+    if username is None or username.strip() == '':
+        context['message'] = _u('Please enter a username')
+        return JsonResponse(context, status=400)
+
+    account_action = request.POST.get('account_action')
+    if account_action is None:
+        context['message'] = _u('Please choose an option')
+        return JsonResponse(context, status=400)
+
+    username = username.strip()
+    try:
+        user = User.objects.get(username=username)
+    except User.DoesNotExist:
+        context['message'] = _u("User with username {} does not exist").format(username)
+        return JsonResponse(context, status=400)
+    else:
+        user_account, _ = UserStanding.objects.get_or_create(
+            user=user, defaults={'changed_by': request.user},
+        )
+        if account_action == 'disable':
+            user_account.account_status = UserStanding.ACCOUNT_DISABLED
+            context['message'] = _u("Successfully disabled {}'s account").format(username)
+            log.info("{} disabled {}'s account".format(request.user, username))
+        elif account_action == 'reenable':
+            user_account.account_status = UserStanding.ACCOUNT_ENABLED
+            context['message'] = _u("Successfully reenabled {}'s account").format(username)
+            log.info("{} reenabled {}'s account".format(request.user, username))
+        else:
+            context['message'] = _u("Unexpected account status")
+            return JsonResponse(context, status=400)
+        user_account.changed_by = request.user
+        user_account.standing_last_changed_at = datetime.datetime.now(UTC)
+        user_account.save()
+
+    return JsonResponse(context)
+
 
 @login_required
 @ensure_csrf_cookie
diff --git a/common/djangoapps/terrain/course_helpers.py b/common/djangoapps/terrain/course_helpers.py
index 22222d30a460..26a60ef9946a 100644
--- a/common/djangoapps/terrain/course_helpers.py
+++ b/common/djangoapps/terrain/course_helpers.py
@@ -2,7 +2,7 @@
 # pylint: disable=W0621
 
 from lettuce import world
-from django.contrib.auth.models import User
+from django.contrib.auth.models import User, Group
 from student.models import CourseEnrollment
 from xmodule.modulestore.django import editable_modulestore
 from xmodule.contentstore.django import contentstore
@@ -41,15 +41,30 @@ def log_in(username='robot', password='test', email='robot@edx.org', name='Robot
 
 
 @world.absorb
-def register_by_course_id(course_id, is_staff=False):
-    create_user('robot', 'password')
-    u = User.objects.get(username='robot')
+def register_by_course_id(course_id, username='robot', password='test', is_staff=False):
+    create_user(username, password)
+    user = User.objects.get(username=username)
     if is_staff:
         u.is_staff = True
         u.save()
     CourseEnrollment.enroll(u, course_id)
 
 
+@world.absorb
+def add_to_course_staff(username, course_num):
+    """
+    Add the user with `username` to the course staff group
+    for `course_num`.
+    """
+    # Based on code in lms/djangoapps/courseware/access.py
+    group_name = "instructor_{}".format(course_num)
+    group, _ = Group.objects.get_or_create(name=group_name)
+    group.save()
+
+    user = User.objects.get(username=username)
+    user.groups.add(group)
+
+
 @world.absorb
 def clear_courses():
     # Flush and initialize the module store
diff --git a/common/djangoapps/terrain/ui_helpers.py b/common/djangoapps/terrain/ui_helpers.py
index e400ca9b95d9..52ab7462a5ae 100644
--- a/common/djangoapps/terrain/ui_helpers.py
+++ b/common/djangoapps/terrain/ui_helpers.py
@@ -45,8 +45,46 @@ def is_css_not_present(css_selector, wait_time=5):
         world.browser.driver.implicitly_wait(world.IMPLICIT_WAIT)
 
 @world.absorb
-def css_has_text(css_selector, text, index=0):
-    return world.css_text(css_selector, index=index) == text
+def css_has_text(css_selector, text, index=0, strip=False):
+    """
+    Return a boolean indicating whether the element with `css_selector`
+    has `text`.
+
+    If `strip` is True, strip whitespace at beginning/end of both
+    strings before comparing.
+
+    If there are multiple elements matching the css selector,
+    use `index` to indicate which one.
+    """
+    # If we're expecting a non-empty string, give the page
+    # a chance to fill in text fields.
+    if text:
+        world.wait_for(lambda _: world.css_text(css_selector, index=index))
+
+    actual_text = world.css_text(css_selector, index=index)
+
+    if strip:
+        actual_text = actual_text.strip()
+        text = text.strip()
+
+    return actual_text == text
+
+
+@world.absorb
+def css_has_value(css_selector, value, index=0):
+    """
+    Return a boolean indicating whether the element with
+    `css_selector` has the specified `value`.
+
+    If there are multiple elements matching the css selector,
+    use `index` to indicate which one.
+    """
+    # If we're expecting a non-empty string, give the page
+    # a chance to fill in values
+    if value:
+        world.wait_for(lambda _: world.css_value(css_selector, index=index))
+
+    return world.css_value(css_selector, index=index) == value
 
 
 @world.absorb
diff --git a/common/lib/xmodule/xmodule/css/video/display.scss b/common/lib/xmodule/xmodule/css/video/display.scss
index c087d180985d..2b4620ebeea2 100644
--- a/common/lib/xmodule/xmodule/css/video/display.scss
+++ b/common/lib/xmodule/xmodule/css/video/display.scss
@@ -392,7 +392,7 @@ div.video {
             @include transition(none);
             -webkit-font-smoothing: antialiased;
             width: 30px;
-          
+
             &:hover, &:active {
               background-color: #444;
               color: #fff;
@@ -457,7 +457,7 @@ div.video {
           text-indent: -9999px;
           @include transition(none);
           width: 30px;
-          
+
           &:hover, &:active {
             background-color: #444;
             color: #fff;
@@ -610,6 +610,8 @@ div.video {
     ol.subtitles {
         width: 0;
         height: 0;
+
+        visibility: hidden;
     }
 
     ol.subtitles.html5 {
@@ -643,6 +645,8 @@ div.video {
       ol.subtitles {
         right: -(flex-grid(4));
         width: auto;
+
+        visibility: hidden;
       }
     }
 
diff --git a/common/lib/xmodule/xmodule/js/fixtures/video.html b/common/lib/xmodule/xmodule/js/fixtures/video.html
index f607430ba06d..e6589128851f 100644
--- a/common/lib/xmodule/xmodule/js/fixtures/video.html
+++ b/common/lib/xmodule/xmodule/js/fixtures/video.html
@@ -12,6 +12,7 @@
         data-autoplay="False"
         data-yt-test-timeout="1500"
         data-yt-test-url="https://gdata.youtube.com/feeds/api/videos/"
+        data-autohide-html5="True"
       >
         <div class="focus_grabber first"></div>
 
diff --git a/common/lib/xmodule/xmodule/js/fixtures/video_all.html b/common/lib/xmodule/xmodule/js/fixtures/video_all.html
index 57052bf65dab..b774134cf7e5 100644
--- a/common/lib/xmodule/xmodule/js/fixtures/video_all.html
+++ b/common/lib/xmodule/xmodule/js/fixtures/video_all.html
@@ -15,6 +15,7 @@
         data-autoplay="False"
         data-yt-test-timeout="1500"
         data-yt-test-url="https://gdata.youtube.com/feeds/api/videos/"
+        data-autohide-html5="True"
       >
         <div class="focus_grabber first"></div>
 
diff --git a/common/lib/xmodule/xmodule/js/fixtures/video_html5.html b/common/lib/xmodule/xmodule/js/fixtures/video_html5.html
index 32789b6ba991..fcb5a3c319d8 100644
--- a/common/lib/xmodule/xmodule/js/fixtures/video_html5.html
+++ b/common/lib/xmodule/xmodule/js/fixtures/video_html5.html
@@ -15,6 +15,7 @@
         data-autoplay="False"
         data-yt-test-timeout="1500"
         data-yt-test-url="https://gdata.youtube.com/feeds/api/videos/"
+        data-autohide-html5="True"
       >
         <div class="focus_grabber first"></div>
 
diff --git a/common/lib/xmodule/xmodule/js/fixtures/video_no_captions.html b/common/lib/xmodule/xmodule/js/fixtures/video_no_captions.html
index 61975784c171..ceb24299e936 100644
--- a/common/lib/xmodule/xmodule/js/fixtures/video_no_captions.html
+++ b/common/lib/xmodule/xmodule/js/fixtures/video_no_captions.html
@@ -12,6 +12,7 @@
         data-autoplay="False"
         data-yt-test-timeout="1500"
         data-yt-test-url="https://gdata.youtube.com/feeds/api/videos/"
+        data-autohide-html5="True"
       >
         <div class="focus_grabber first"></div>
 
diff --git a/common/lib/xmodule/xmodule/js/fixtures/video_yt_multiple.html b/common/lib/xmodule/xmodule/js/fixtures/video_yt_multiple.html
index c6b40cdf164d..bf9272d230c7 100644
--- a/common/lib/xmodule/xmodule/js/fixtures/video_yt_multiple.html
+++ b/common/lib/xmodule/xmodule/js/fixtures/video_yt_multiple.html
@@ -12,6 +12,7 @@
         data-autoplay="False"
         data-yt-test-timeout="1500"
         data-yt-test-url="https://gdata.youtube.com/feeds/api/videos/"
+        data-autohide-html5="True"
       >
         <div class="focus_grabber first"></div>
 
@@ -73,6 +74,8 @@ <h3>Speed</h3>
         data-autoplay="False"
         data-yt-test-timeout="1500"
         data-yt-test-url="https://gdata.youtube.com/feeds/api/videos/"
+
+        data-autohide-html5="True"
       >
         <div class="tc-wrapper">
           <article class="video-wrapper">
@@ -130,6 +133,8 @@ <h3>Speed</h3>
         data-autoplay="False"
         data-yt-test-timeout="1500"
         data-yt-test-url="https://gdata.youtube.com/feeds/api/videos/"
+
+        data-autohide-html5="True"
       >
         <div class="tc-wrapper">
           <article class="video-wrapper">
diff --git a/common/lib/xmodule/xmodule/js/spec/video/video_caption_spec.js b/common/lib/xmodule/xmodule/js/spec/video/video_caption_spec.js
index 0f729da62d4d..061576efd23a 100644
--- a/common/lib/xmodule/xmodule/js/spec/video/video_caption_spec.js
+++ b/common/lib/xmodule/xmodule/js/spec/video/video_caption_spec.js
@@ -1,673 +1,798 @@
-(function() {
-  describe('VideoCaption', function() {
-    var state, videoPlayer, videoCaption, videoSpeedControl, oldOTBD;
-
-    function initialize() {
-      loadFixtures('video_all.html');
-      state = new Video('#example');
-      videoPlayer = state.videoPlayer;
-      videoCaption = state.videoCaption;
-      videoSpeedControl = state.videoSpeedControl;
-      videoControl = state.videoControl;
-    }
-
-    beforeEach(function() {
-      oldOTBD = window.onTouchBasedDevice;
-      window.onTouchBasedDevice = jasmine.createSpy('onTouchBasedDevice').andReturn(false);
-      initialize();
-    });
-
-    afterEach(function() {
-      YT.Player = void 0;
-      $.fn.scrollTo.reset();
-      $('.subtitles').remove();
-      $('source').remove();
-      window.onTouchBasedDevice = oldOTBD;
-    });
-
-    describe('constructor', function() {
-      describe('always', function() {
-        beforeEach(function() {
-          spyOn($, 'ajaxWithPrefix').andCallThrough();
-          initialize();
-        });
-
-        it('create the caption element', function() {
-          expect($('.video')).toContain('ol.subtitles');
-        });
-
-        it('add caption control to video player', function() {
-          expect($('.video')).toContain('a.hide-subtitles');
-        });
-
-        it('fetch the caption', function() {
-          waitsFor(function () {
-            if (videoCaption.loaded === true) {
-                return true;
-            }
-
-            return false;
-          }, 'Expect captions to be loaded.', 1000);
-
-          runs(function () {
-              expect($.ajaxWithPrefix).toHaveBeenCalledWith({
-                url: videoCaption.captionURL(),
-                notifyOnError: false,
-                success: jasmine.any(Function),
-                error: jasmine.any(Function),
-              });
-          });
-        });
-
-        it('bind window resize event', function() {
-          expect($(window)).toHandleWith('resize', videoCaption.resize);
-        });
-
-        it('bind the hide caption button', function() {
-          expect($('.hide-subtitles')).toHandleWith('click', videoCaption.toggle);
-        });
-
-        it('bind the mouse movement', function() {
-          expect($('.subtitles')).toHandleWith('mouseover', videoCaption.onMouseEnter);
-          expect($('.subtitles')).toHandleWith('mouseout', videoCaption.onMouseLeave);
-          expect($('.subtitles')).toHandleWith('mousemove', videoCaption.onMovement);
-          expect($('.subtitles')).toHandleWith('mousewheel', videoCaption.onMovement);
-          expect($('.subtitles')).toHandleWith('DOMMouseScroll', videoCaption.onMovement);
-        });
-
-        it('bind the scroll', function() {
-          expect($('.subtitles')).toHandleWith('scroll', videoCaption.autoShowCaptions);
-          expect($('.subtitles')).toHandleWith('scroll', videoControl.showControls);
-        });
-      });
-
-      describe('when on a non touch-based device', function() {
-        beforeEach(function() {
-          initialize();
-        });
-
-        it('render the caption', function() {
-          var captionsData;
-
-          captionsData = jasmine.stubbedCaption;
-          $('.subtitles li[data-index]').each(function(index, link) {
-            expect($(link)).toHaveData('index', index);
-            expect($(link)).toHaveData('start', captionsData.start[index]);
-            expect($(link)).toHaveAttr('tabindex', 0);
-            expect($(link)).toHaveText(captionsData.text[index]);
-          });
-        });
-
-        it('add a padding element to caption', function() {
-          expect($('.subtitles li:first').hasClass('spacing')).toBe(true);
-          expect($('.subtitles li:last').hasClass('spacing')).toBe(true);
-        });
-
-        it('bind all the caption link', function() {
-          $('.subtitles li[data-index]').each(function(index, link) {
-            expect($(link)).toHandleWith('mouseover', videoCaption.captionMouseOverOut);
-            expect($(link)).toHandleWith('mouseout', videoCaption.captionMouseOverOut);
-            expect($(link)).toHandleWith('mousedown', videoCaption.captionMouseDown);
-            expect($(link)).toHandleWith('click', videoCaption.captionClick);
-            expect($(link)).toHandleWith('focus', videoCaption.captionFocus);
-            expect($(link)).toHandleWith('blur', videoCaption.captionBlur);
-            expect($(link)).toHandleWith('keydown', videoCaption.captionKeyDown);
-          });
-        });
-
-        it('set rendered to true', function() {
-          expect(videoCaption.rendered).toBeTruthy();
-        });
-      });
-
-      describe('when on a touch-based device', function() {
-        beforeEach(function() {
-          window.onTouchBasedDevice.andReturn(true);
-          initialize();
-        });
-
-        it('show explaination message', function() {
-          expect($('.subtitles li')).toHaveHtml("Caption will be displayed when you start playing the video.");
-        });
-
-        it('does not set rendered to true', function() {
-          expect(videoCaption.rendered).toBeFalsy();
-        });
-      });
-
-      describe('when no captions file was specified', function () {
-        beforeEach(function () {
-          loadFixtures('video_all.html');
-
-          // Unspecify the captions file.
-          $('#example').find('#video_id').data('sub', '');
-
-          state = new Video('#example');
-          videoCaption = state.videoCaption;
-        });
-
-        it('captions panel is not shown', function () {
-          expect(videoCaption.hideSubtitlesEl).toBeHidden();
-        });
-      });
-    });
-
-    describe('mouse movement', function() {
-      // We will store default window.setTimeout() function here.
-      var oldSetTimeout = null;
-
-      beforeEach(function() {
-        // Store original window.setTimeout() function. If we do not do this, then
-        // all other tests that rely on code which uses window.setTimeout()
-        // function might (and probably will) fail.
-        oldSetTimeout = window.setTimeout;
-        // Redefine window.setTimeout() function as a spy.
-        window.setTimeout = jasmine.createSpy().andCallFake(function(callback, timeout) { return 5; })
-        window.setTimeout.andReturn(100);
-        spyOn(window, 'clearTimeout');
-      });
-
-      afterEach(function () {
-        // Reset the default window.setTimeout() function. If we do not do this,
-        // then all other tests that rely on code which uses window.setTimeout()
-        // function might (and probably will) fail.
-        window.setTimeout = oldSetTimeout;
-      });
-
-      describe('when cursor is outside of the caption box', function() {
-        beforeEach(function() {
-          $(window).trigger(jQuery.Event('mousemove'));
-        });
-
-        it('does not set freezing timeout', function() {
-          expect(videoCaption.frozen).toBeFalsy();
-        });
-      });
-
-      describe('when cursor is in the caption box', function() {
-        beforeEach(function() {
-          $('.subtitles').trigger(jQuery.Event('mouseenter'));
-        });
-
-        it('set the freezing timeout', function() {
-          expect(videoCaption.frozen).toEqual(100);
-        });
-
-        describe('when the cursor is moving', function() {
-          beforeEach(function() {
-            $('.subtitles').trigger(jQuery.Event('mousemove'));
-          });
-
-          it('reset the freezing timeout', function() {
-            expect(window.clearTimeout).toHaveBeenCalledWith(100);
-          });
-        });
-
-        describe('when the mouse is scrolling', function() {
-          beforeEach(function() {
-            $('.subtitles').trigger(jQuery.Event('mousewheel'));
-          });
-
-          it('reset the freezing timeout', function() {
-            expect(window.clearTimeout).toHaveBeenCalledWith(100);
-          });
-        });
-      });
-
-      describe('when cursor is moving out of the caption box', function() {
-        beforeEach(function() {
-          videoCaption.frozen = 100;
-          $.fn.scrollTo.reset();
-        });
-
-        describe('always', function() {
-          beforeEach(function() {
-            $('.subtitles').trigger(jQuery.Event('mouseout'));
-          });
-
-          it('reset the freezing timeout', function() {
-            expect(window.clearTimeout).toHaveBeenCalledWith(100);
-          });
-
-          it('unfreeze the caption', function() {
-            expect(videoCaption.frozen).toBeNull();
-          });
-        });
-
-        describe('when the player is playing', function() {
-          beforeEach(function() {
-            videoCaption.playing = true;
-            $('.subtitles li[data-index]:first').addClass('current');
-            $('.subtitles').trigger(jQuery.Event('mouseout'));
-          });
-
-          it('scroll the caption', function() {
-            expect($.fn.scrollTo).toHaveBeenCalled();
-          });
-        });
-
-        describe('when the player is not playing', function() {
-          beforeEach(function() {
-            videoCaption.playing = false;
-            $('.subtitles').trigger(jQuery.Event('mouseout'));
-          });
-
-          it('does not scroll the caption', function() {
-            expect($.fn.scrollTo).not.toHaveBeenCalled();
-          });
-        });
-      });
-    });
-
-    describe('search', function() {
-      it('return a correct caption index', function() {
-        expect(videoCaption.search(0)).toEqual(-1);
-        expect(videoCaption.search(3120)).toEqual(1);
-        expect(videoCaption.search(6270)).toEqual(2);
-        expect(videoCaption.search(8490)).toEqual(2);
-        expect(videoCaption.search(21620)).toEqual(4);
-        expect(videoCaption.search(24920)).toEqual(5);
-      });
-    });
-
-    describe('play', function() {
-      describe('when the caption was not rendered', function() {
-        beforeEach(function() {
-          window.onTouchBasedDevice.andReturn(true);
-          initialize();
-          videoCaption.play();
-        });
-
-        it('render the caption', function() {
-          var captionsData;
-
-          captionsData = jasmine.stubbedCaption;
-          $('.subtitles li[data-index]').each(function(index, link) {
-            expect($(link)).toHaveData('index', index);
-            expect($(link)).toHaveData('start', captionsData.start[index]);
-            expect($(link)).toHaveAttr('tabindex', 0);
-            expect($(link)).toHaveText(captionsData.text[index]);
-          });
-        });
-
-        it('add a padding element to caption', function() {
-          expect($('.subtitles li:first')).toBe('.spacing');
-          expect($('.subtitles li:last')).toBe('.spacing');
-        });
-
-        it('bind all the caption link', function() {
-          $('.subtitles li[data-index]').each(function(index, link) {
-            expect($(link)).toHandleWith('mouseover', videoCaption.captionMouseOverOut);
-            expect($(link)).toHandleWith('mouseout', videoCaption.captionMouseOverOut);
-            expect($(link)).toHandleWith('mousedown', videoCaption.captionMouseDown);
-            expect($(link)).toHandleWith('click', videoCaption.captionClick);
-            expect($(link)).toHandleWith('focus', videoCaption.captionFocus);
-            expect($(link)).toHandleWith('blur', videoCaption.captionBlur);
-            expect($(link)).toHandleWith('keydown', videoCaption.captionKeyDown);
-          });
-        });
-
-        it('set rendered to true', function() {
-          expect(videoCaption.rendered).toBeTruthy();
-        });
-
-        it('set playing to true', function() {
-          expect(videoCaption.playing).toBeTruthy();
-        });
-      });
-    });
-
-    describe('pause', function() {
-      beforeEach(function() {
-        videoCaption.playing = true;
-        videoCaption.pause();
-      });
-
-      it('set playing to false', function() {
-        expect(videoCaption.playing).toBeFalsy();
-      });
-    });
-
-    describe('updatePlayTime', function() {
-      describe('when the video speed is 1.0x', function() {
-        beforeEach(function() {
-          videoSpeedControl.currentSpeed = '1.0';
-          videoCaption.updatePlayTime(25.000);
-        });
-
-        it('search the caption based on time', function() {
-          expect(videoCaption.currentIndex).toEqual(5);
-        });
-      });
-
-      describe('when the video speed is not 1.0x', function() {
-        beforeEach(function() {
-          videoSpeedControl.currentSpeed = '0.75';
-          videoCaption.updatePlayTime(25.000);
-        });
-
-        it('search the caption based on 1.0x speed', function() {
-          expect(videoCaption.currentIndex).toEqual(5);
-        });
-      });
-
-      describe('when the index is not the same', function() {
-        beforeEach(function() {
-          videoCaption.currentIndex = 1;
-          $('.subtitles li[data-index=5]').addClass('current');
-          videoCaption.updatePlayTime(25.000);
-        });
-
-        it('deactivate the previous caption', function() {
-          expect($('.subtitles li[data-index=1]')).not.toHaveClass('current');
-        });
-
-        it('activate new caption', function() {
-          expect($('.subtitles li[data-index=5]')).toHaveClass('current');
-        });
-
-        it('save new index', function() {
-          expect(videoCaption.currentIndex).toEqual(5);
-        });
-
-        it('scroll caption to new position', function() {
-          expect($.fn.scrollTo).toHaveBeenCalled();
-        });
-      });
-
-      describe('when the index is the same', function() {
-        beforeEach(function() {
-          videoCaption.currentIndex = 1;
-          $('.subtitles li[data-index=3]').addClass('current');
-          videoCaption.updatePlayTime(15.000);
-        });
-
-        it('does not change current subtitle', function() {
-          expect($('.subtitles li[data-index=3]')).toHaveClass('current');
-        });
-      });
-    });
-
-    describe('resize', function() {
-      beforeEach(function() {
-        initialize();
-        $('.subtitles li[data-index=1]').addClass('current');
-        videoCaption.resize();
-      });
-
-      describe('set the height of caption container', function(){
-        // Temporarily disabled due to intermittent failures
-        // with error "Expected 745 to be close to 805, 2." in Firefox
-        xit('when CC button is enabled', function() {
-          var realHeight = parseInt($('.subtitles').css('maxHeight'), 10),
-              shouldBeHeight = $('.video-wrapper').height();
-
-          // Because of some problems with rounding on different enviroments:
-          // Linux * Mac * FF * Chrome
-          expect(realHeight).toBeCloseTo(shouldBeHeight, 2);
-        });
-
-        it('when CC button is disabled ', function() {
-          var realHeight, videoWrapperHeight, progressSliderHeight,
-            controlHeight, shouldBeHeight;
-
-          state.captionsHidden = true;
-          videoCaption.setSubtitlesHeight();
-
-          realHeight = parseInt($('.subtitles').css('maxHeight'), 10);
-          videoWrapperHeight = $('.video-wrapper').height();
-          progressSliderHeight = videoControl.sliderEl.height();
-          controlHeight = videoControl.el.height();
-          shouldBeHeight = videoWrapperHeight -
-                           0.5 * progressSliderHeight -
-                           controlHeight;
-
-          expect(realHeight).toBe(shouldBeHeight);
-        });
-      });
-
-      it('set the height of caption spacing', function() {
-        var firstSpacing, lastSpacing;
-        firstSpacing = Math.abs(parseInt($('.subtitles .spacing:first').css('height'), 10));
-        lastSpacing = Math.abs(parseInt($('.subtitles .spacing:last').css('height'), 10));
-        expect(firstSpacing - videoCaption.topSpacingHeight()).toBeLessThan(1);
-        expect(lastSpacing - videoCaption.bottomSpacingHeight()).toBeLessThan(1);
-      });
-
-      it('scroll caption to new position', function() {
-        expect($.fn.scrollTo).toHaveBeenCalled();
-      });
-    });
-
-    describe('scrollCaption', function() {
-      beforeEach(function() {
-        initialize();
-      });
-
-      describe('when frozen', function() {
-        beforeEach(function() {
-          videoCaption.frozen = true;
-          $('.subtitles li[data-index=1]').addClass('current');
-          videoCaption.scrollCaption();
-        });
-
-        it('does not scroll the caption', function() {
-          expect($.fn.scrollTo).not.toHaveBeenCalled();
-        });
-      });
-
-      describe('when not frozen', function() {
-        beforeEach(function() {
-          videoCaption.frozen = false;
-        });
-
-        describe('when there is no current caption', function() {
-          beforeEach(function() {
-            videoCaption.scrollCaption();
-          });
-
-          it('does not scroll the caption', function() {
-            expect($.fn.scrollTo).not.toHaveBeenCalled();
-          });
-        });
-
-        describe('when there is a current caption', function() {
-          beforeEach(function() {
-            $('.subtitles li[data-index=1]').addClass('current');
-            videoCaption.scrollCaption();
-          });
-
-          it('scroll to current caption', function() {
-            expect($.fn.scrollTo).toHaveBeenCalled();
-          });
-        });
-      });
-    });
-
-    describe('seekPlayer', function() {
-      describe('when the video speed is 1.0x', function() {
-        beforeEach(function() {
-          videoSpeedControl.currentSpeed = '1.0';
-          $('.subtitles li[data-start="14910"]').trigger('click');
-        });
-
-        // Temporarily disabled due to intermittent failures
-        // Fails with error: "InvalidStateError: An attempt was made to
-        // use an object that is not, or is no longer, usable
-        // Expected 0 to equal 14.91."
-        // on Firefox
-        xit('trigger seek event with the correct time', function() {
-          expect(videoPlayer.currentTime).toEqual(14.91);
-        });
-      });
-
-      describe('when the video speed is not 1.0x', function() {
-        beforeEach(function() {
-          initialize();
-          videoSpeedControl.currentSpeed = '0.75';
-          $('.subtitles li[data-start="14910"]').trigger('click');
-        });
-
-        it('trigger seek event with the correct time', function() {
-          expect(videoPlayer.currentTime).toEqual(14.91);
-        });
-      });
+(function () {
+    describe('VideoCaption', function () {
+        var state, videoPlayer, videoCaption, videoSpeedControl, oldOTBD;
+
+        function initialize() {
+            loadFixtures('video_all.html');
+            state = new Video('#example');
+            videoPlayer = state.videoPlayer;
+            videoCaption = state.videoCaption;
+            videoSpeedControl = state.videoSpeedControl;
+            videoControl = state.videoControl;
+        }
 
-      describe('when the player type is Flash at speed 0.75x', function () {
         beforeEach(function () {
+            oldOTBD = window.onTouchBasedDevice;
+            window.onTouchBasedDevice = jasmine.createSpy('onTouchBasedDevice')
+                .andReturn(false);
             initialize();
-            videoSpeedControl.currentSpeed = '0.75';
-            state.currentPlayerMode = 'flash';
-            $('.subtitles li[data-start="14910"]').trigger('click');
-        });
-
-        it('trigger seek event with the correct time', function () {
-            expect(videoPlayer.currentTime).toEqual(15);
-        });
-      });
-    });
-
-    describe('toggle', function() {
-      beforeEach(function() {
-        initialize();
-        spyOn(videoPlayer, 'log');
-        $('.subtitles li[data-index=1]').addClass('current');
-      });
-
-      describe('when the caption is visible', function() {
-        beforeEach(function() {
-          state.el.removeClass('closed');
-          videoCaption.toggle(jQuery.Event('click'));
-        });
-
-        it('log the hide_transcript event', function() {
-          expect(videoPlayer.log).toHaveBeenCalledWith('hide_transcript', {
-            currentTime: videoPlayer.currentTime
-          });
-        });
-
-        it('hide the caption', function() {
-          expect(state.el).toHaveClass('closed');
-        });
-      });
-
-      describe('when the caption is hidden', function() {
-        beforeEach(function() {
-          state.el.addClass('closed');
-          videoCaption.toggle(jQuery.Event('click'));
-        });
-
-        it('log the show_transcript event', function() {
-          expect(videoPlayer.log).toHaveBeenCalledWith('show_transcript', {
-            currentTime: videoPlayer.currentTime
-          });
-        });
-
-        it('show the caption', function() {
-          expect(state.el).not.toHaveClass('closed');
-        });
-
-        it('scroll the caption', function() {
-          expect($.fn.scrollTo).toHaveBeenCalled();
-        });
-      });
-    });
-
-    describe('caption accessibility', function() {
-      beforeEach(function() {
-        initialize();
-      });
-
-      describe('when getting focus through TAB key', function() {
-        beforeEach(function() {
-          videoCaption.isMouseFocus = false;
-          $('.subtitles li[data-index=0]').trigger(jQuery.Event('focus'));
-        });
-
-        it('shows an outline around the caption', function() {
-          expect($('.subtitles li[data-index=0]')).toHaveClass('focused');
-        });
-
-        it('has automatic scrolling disabled', function() {
-          expect(videoCaption.autoScrolling).toBe(false);
-        });
-      });
-
-      describe('when loosing focus through TAB key', function() {
-        beforeEach(function() {
-          $('.subtitles li[data-index=0]').trigger(jQuery.Event('blur'));
-        });
-
-        it('does not show an outline around the caption', function() {
-          expect($('.subtitles li[data-index=0]')).not.toHaveClass('focused');
-        });
-
-        it('has automatic scrolling enabled', function() {
-          expect(videoCaption.autoScrolling).toBe(true);
-        });
-      });
-
-      describe('when same caption gets the focus through mouse after having focus through TAB key', function() {
-        beforeEach(function() {
-          videoCaption.isMouseFocus = false;
-          $('.subtitles li[data-index=0]').trigger(jQuery.Event('focus'));
-          $('.subtitles li[data-index=0]').trigger(jQuery.Event('mousedown'));
-        });
-
-        it('does not show an outline around it', function() {
-          expect($('.subtitles li[data-index=0]')).not.toHaveClass('focused');
-        });
-
-        it('has automatic scrolling enabled', function() {
-          expect(videoCaption.autoScrolling).toBe(true);
-        });
-      });
-
-      describe('when a second caption gets focus through mouse after first had focus through TAB key', function() {
-        beforeEach(function() {
-          videoCaption.isMouseFocus = false;
-          $('.subtitles li[data-index=0]').trigger(jQuery.Event('focus'));
-          $('.subtitles li[data-index=0]').trigger(jQuery.Event('blur'));
-          videoCaption.isMouseFocus = true;
-          $('.subtitles li[data-index=1]').trigger(jQuery.Event('mousedown'));
-        });
-
-        it('does not show an outline around the first', function() {
-          expect($('.subtitles li[data-index=0]')).not.toHaveClass('focused');
-        });
-
-        it('does not show an outline around the second', function() {
-          expect($('.subtitles li[data-index=1]')).not.toHaveClass('focused');
-        });
-
-        it('has automatic scrolling enabled', function() {
-          expect(videoCaption.autoScrolling).toBe(true);
-        });
-      });
-
-      xdescribe('when enter key is pressed on a caption', function() {
-        beforeEach(function() {
-          var e;
-          spyOn(videoCaption, 'seekPlayer').andCallThrough();
-          videoCaption.isMouseFocus = false;
-          $('.subtitles li[data-index=0]').trigger(jQuery.Event('focus'));
-          e = jQuery.Event('keydown');
-          e.which = 13; // ENTER key
-          $('.subtitles li[data-index=0]').trigger(e);
-        });
-
-        // Temporarily disabled due to intermittent failures
-        // Fails with error: "InvalidStateError: InvalidStateError: An attempt
-        // was made to use an object that is not, or is no longer, usable"
-        xit('shows an outline around it', function() {
-          expect($('.subtitles li[data-index=0]')).toHaveClass('focused');
         });
 
-        xit('calls seekPlayer', function() {
-           expect(videoCaption.seekPlayer).toHaveBeenCalled();
+        afterEach(function () {
+            YT.Player = undefined;
+            $.fn.scrollTo.reset();
+            $('.subtitles').remove();
+            $('source').remove();
+            window.onTouchBasedDevice = oldOTBD;
+        });
+
+        describe('constructor', function () {
+            describe('always', function () {
+                beforeEach(function () {
+                    spyOn($, 'ajaxWithPrefix').andCallThrough();
+                    initialize();
+                });
+
+                it('create the caption element', function () {
+                    expect($('.video')).toContain('ol.subtitles');
+                });
+
+                it('add caption control to video player', function () {
+                    expect($('.video')).toContain('a.hide-subtitles');
+                });
+
+                it('fetch the caption', function () {
+                    waitsFor(function () {
+                        if (videoCaption.loaded === true) {
+                            return true;
+                        }
+
+                        return false;
+                    }, 'Expect captions to be loaded.', 1000);
+
+                    runs(function () {
+                        expect($.ajaxWithPrefix).toHaveBeenCalledWith({
+                            url: videoCaption.captionURL(),
+                            notifyOnError: false,
+                            success: jasmine.any(Function),
+                            error: jasmine.any(Function)
+                        });
+                    });
+                });
+
+                it('bind window resize event', function () {
+                    expect($(window)).toHandleWith(
+                        'resize', videoCaption.resize
+                    );
+                });
+
+                it('bind the hide caption button', function () {
+                    expect($('.hide-subtitles')).toHandleWith(
+                        'click', videoCaption.toggle
+                    );
+                });
+
+                it('bind the mouse movement', function () {
+                    expect($('.subtitles')).toHandleWith(
+                        'mouseover', videoCaption.onMouseEnter
+                    );
+                    expect($('.subtitles')).toHandleWith(
+                        'mouseout', videoCaption.onMouseLeave
+                    );
+                    expect($('.subtitles')).toHandleWith(
+                        'mousemove', videoCaption.onMovement
+                    );
+                    expect($('.subtitles')).toHandleWith(
+                        'mousewheel', videoCaption.onMovement
+                    );
+                    expect($('.subtitles')).toHandleWith(
+                        'DOMMouseScroll', videoCaption.onMovement
+                    );
+                });
+
+                it('bind the scroll', function () {
+                    expect($('.subtitles'))
+                        .toHandleWith('scroll', videoCaption.autoShowCaptions);
+                    expect($('.subtitles'))
+                        .toHandleWith('scroll', videoControl.showControls);
+                });
+            });
+
+            describe('when on a non touch-based device', function () {
+                beforeEach(function () {
+                    initialize();
+                });
+
+                it('render the caption', function () {
+                    var captionsData;
+
+                    captionsData = jasmine.stubbedCaption;
+                    $('.subtitles li[data-index]').each(
+                        function (index, link) {
+
+                        expect($(link)).toHaveData('index', index);
+                        expect($(link)).toHaveData(
+                            'start', captionsData.start[index]
+                        );
+                        expect($(link)).toHaveAttr('tabindex', 0);
+                        expect($(link)).toHaveText(captionsData.text[index]);
+                    });
+                });
+
+                it('add a padding element to caption', function () {
+                    expect($('.subtitles li:first').hasClass('spacing'))
+                        .toBe(true);
+                    expect($('.subtitles li:last').hasClass('spacing'))
+                        .toBe(true);
+                });
+
+                it('bind all the caption link', function () {
+                    $('.subtitles li[data-index]').each(
+                        function (index, link) {
+
+                        expect($(link)).toHandleWith(
+                            'mouseover', videoCaption.captionMouseOverOut
+                        );
+                        expect($(link)).toHandleWith(
+                            'mouseout', videoCaption.captionMouseOverOut
+                        );
+                        expect($(link)).toHandleWith(
+                            'mousedown', videoCaption.captionMouseDown
+                        );
+                        expect($(link)).toHandleWith(
+                            'click', videoCaption.captionClick
+                        );
+                        expect($(link)).toHandleWith(
+                            'focus', videoCaption.captionFocus
+                        );
+                        expect($(link)).toHandleWith(
+                            'blur', videoCaption.captionBlur
+                        );
+                        expect($(link)).toHandleWith(
+                            'keydown', videoCaption.captionKeyDown
+                        );
+                    });
+                });
+
+                it('set rendered to true', function () {
+                    expect(videoCaption.rendered).toBeTruthy();
+                });
+            });
+
+            describe('when on a touch-based device', function () {
+                beforeEach(function () {
+                    window.onTouchBasedDevice.andReturn(true);
+                    initialize();
+                });
+
+                it('show explaination message', function () {
+                    expect($('.subtitles li')).toHaveHtml(
+                        'Caption will be displayed when you start playing ' +
+                        'the video.'
+                    );
+                });
+
+                it('does not set rendered to true', function () {
+                    expect(videoCaption.rendered).toBeFalsy();
+                });
+            });
+
+            describe('when no captions file was specified', function () {
+                beforeEach(function () {
+                    loadFixtures('video_all.html');
+
+                    // Unspecify the captions file.
+                    $('#example').find('#video_id').data('sub', '');
+
+                    state = new Video('#example');
+                    videoCaption = state.videoCaption;
+                });
+
+                it('captions panel is not shown', function () {
+                    expect(videoCaption.hideSubtitlesEl).toBeHidden();
+                });
+            });
+        });
+
+        describe('mouse movement', function () {
+            // We will store default window.setTimeout() function here.
+            var oldSetTimeout = null;
+
+            beforeEach(function () {
+                // Store original window.setTimeout() function. If we do not do
+                // this, then all other tests that rely on code which uses
+                // window.setTimeout() function might (and probably will) fail.
+                oldSetTimeout = window.setTimeout;
+                // Redefine window.setTimeout() function as a spy.
+                window.setTimeout = jasmine.createSpy().andCallFake(
+                    function (callback, timeout) {
+                        return 5;
+                    }
+                );
+                window.setTimeout.andReturn(100);
+                spyOn(window, 'clearTimeout');
+            });
+
+            afterEach(function () {
+                // Reset the default window.setTimeout() function. If we do not
+                // do this, then all other tests that rely on code which uses
+                // window.setTimeout() function might (and probably will) fail.
+                window.setTimeout = oldSetTimeout;
+            });
+
+            describe('when cursor is outside of the caption box', function () {
+                beforeEach(function () {
+                    $(window).trigger(jQuery.Event('mousemove'));
+                });
+
+                it('does not set freezing timeout', function () {
+                    expect(videoCaption.frozen).toBeFalsy();
+                });
+            });
+
+            describe('when cursor is in the caption box', function () {
+                beforeEach(function () {
+                    $('.subtitles').trigger(jQuery.Event('mouseenter'));
+                });
+
+                it('set the freezing timeout', function () {
+                    expect(videoCaption.frozen).toEqual(100);
+                });
+
+                describe('when the cursor is moving', function () {
+                    beforeEach(function () {
+                        $('.subtitles').trigger(jQuery.Event('mousemove'));
+                    });
+
+                    it('reset the freezing timeout', function () {
+                        expect(window.clearTimeout).toHaveBeenCalledWith(100);
+                    });
+                });
+
+                describe('when the mouse is scrolling', function () {
+                    beforeEach(function () {
+                        $('.subtitles').trigger(jQuery.Event('mousewheel'));
+                    });
+
+                    it('reset the freezing timeout', function () {
+                        expect(window.clearTimeout).toHaveBeenCalledWith(100);
+                    });
+                });
+            });
+
+            describe(
+                'when cursor is moving out of the caption box',
+                function () {
+
+                beforeEach(function () {
+                    videoCaption.frozen = 100;
+                    $.fn.scrollTo.reset();
+                });
+
+                describe('always', function () {
+                    beforeEach(function () {
+                        $('.subtitles').trigger(jQuery.Event('mouseout'));
+                    });
+
+                    it('reset the freezing timeout', function () {
+                        expect(window.clearTimeout).toHaveBeenCalledWith(100);
+                    });
+
+                    it('unfreeze the caption', function () {
+                        expect(videoCaption.frozen).toBeNull();
+                    });
+                });
+
+                describe('when the player is playing', function () {
+                    beforeEach(function () {
+                        videoCaption.playing = true;
+                        $('.subtitles li[data-index]:first')
+                            .addClass('current');
+                        $('.subtitles').trigger(jQuery.Event('mouseout'));
+                    });
+
+                    it('scroll the caption', function () {
+                        expect($.fn.scrollTo).toHaveBeenCalled();
+                    });
+                });
+
+                describe('when the player is not playing', function () {
+                    beforeEach(function () {
+                        videoCaption.playing = false;
+                        $('.subtitles').trigger(jQuery.Event('mouseout'));
+                    });
+
+                    it('does not scroll the caption', function () {
+                        expect($.fn.scrollTo).not.toHaveBeenCalled();
+                    });
+                });
+            });
+        });
+
+        describe('search', function () {
+            it('return a correct caption index', function () {
+                expect(videoCaption.search(0)).toEqual(-1);
+                expect(videoCaption.search(3120)).toEqual(1);
+                expect(videoCaption.search(6270)).toEqual(2);
+                expect(videoCaption.search(8490)).toEqual(2);
+                expect(videoCaption.search(21620)).toEqual(4);
+                expect(videoCaption.search(24920)).toEqual(5);
+            });
+        });
+
+        describe('play', function () {
+            describe('when the caption was not rendered', function () {
+                beforeEach(function () {
+                    window.onTouchBasedDevice.andReturn(true);
+                    initialize();
+                    videoCaption.play();
+                });
+
+                it('render the caption', function () {
+                    var captionsData;
+
+                    captionsData = jasmine.stubbedCaption;
+                    $('.subtitles li[data-index]').each(
+                        function (index, link) {
+
+                        expect($(link)).toHaveData('index', index);
+                        expect($(link)).toHaveData(
+                            'start', captionsData.start[index]
+                        );
+                        expect($(link)).toHaveAttr('tabindex', 0);
+                        expect($(link)).toHaveText(captionsData.text[index]);
+                    });
+                });
+
+                it('add a padding element to caption', function () {
+                    expect($('.subtitles li:first')).toBe('.spacing');
+                    expect($('.subtitles li:last')).toBe('.spacing');
+                });
+
+                it('bind all the caption link', function () {
+                    $('.subtitles li[data-index]').each(
+                        function (index, link) {
+
+                        expect($(link)).toHandleWith(
+                            'mouseover', videoCaption.captionMouseOverOut
+                        );
+                        expect($(link)).toHandleWith(
+                            'mouseout', videoCaption.captionMouseOverOut
+                        );
+                        expect($(link)).toHandleWith(
+                            'mousedown', videoCaption.captionMouseDown
+                        );
+                        expect($(link)).toHandleWith(
+                            'click', videoCaption.captionClick
+                        );
+                        expect($(link)).toHandleWith(
+                            'focus', videoCaption.captionFocus
+                        );
+                        expect($(link)).toHandleWith(
+                            'blur', videoCaption.captionBlur
+                        );
+                        expect($(link)).toHandleWith(
+                            'keydown', videoCaption.captionKeyDown
+                        );
+                    });
+                });
+
+                it('set rendered to true', function () {
+                    expect(videoCaption.rendered).toBeTruthy();
+                });
+
+                it('set playing to true', function () {
+                    expect(videoCaption.playing).toBeTruthy();
+                });
+            });
+        });
+
+        describe('pause', function () {
+            beforeEach(function () {
+                videoCaption.playing = true;
+                videoCaption.pause();
+            });
+
+            it('set playing to false', function () {
+                expect(videoCaption.playing).toBeFalsy();
+            });
+        });
+
+        describe('updatePlayTime', function () {
+            describe('when the video speed is 1.0x', function () {
+                beforeEach(function () {
+                    videoSpeedControl.currentSpeed = '1.0';
+                    videoCaption.updatePlayTime(25.000);
+                });
+
+                it('search the caption based on time', function () {
+                    expect(videoCaption.currentIndex).toEqual(5);
+                });
+            });
+
+            describe('when the video speed is not 1.0x', function () {
+                beforeEach(function () {
+                    videoSpeedControl.currentSpeed = '0.75';
+                    videoCaption.updatePlayTime(25.000);
+                });
+
+                it('search the caption based on 1.0x speed', function () {
+                    expect(videoCaption.currentIndex).toEqual(5);
+                });
+            });
+
+            describe('when the index is not the same', function () {
+                beforeEach(function () {
+                    videoCaption.currentIndex = 1;
+                    $('.subtitles li[data-index=5]').addClass('current');
+                    videoCaption.updatePlayTime(25.000);
+                });
+
+                it('deactivate the previous caption', function () {
+                    expect($('.subtitles li[data-index=1]'))
+                        .not.toHaveClass('current');
+                });
+
+                it('activate new caption', function () {
+                    expect($('.subtitles li[data-index=5]'))
+                        .toHaveClass('current');
+                });
+
+                it('save new index', function () {
+                    expect(videoCaption.currentIndex).toEqual(5);
+                });
+
+                it('scroll caption to new position', function () {
+                    expect($.fn.scrollTo).toHaveBeenCalled();
+                });
+            });
+
+            describe('when the index is the same', function () {
+                beforeEach(function () {
+                    videoCaption.currentIndex = 1;
+                    $('.subtitles li[data-index=3]').addClass('current');
+                    videoCaption.updatePlayTime(15.000);
+                });
+
+                it('does not change current subtitle', function () {
+                    expect($('.subtitles li[data-index=3]'))
+                        .toHaveClass('current');
+                });
+            });
+        });
+
+        describe('resize', function () {
+            beforeEach(function () {
+                initialize();
+                $('.subtitles li[data-index=1]').addClass('current');
+                videoCaption.resize();
+            });
+
+            describe('set the height of caption container', function () {
+                // Temporarily disabled due to intermittent failures
+                // with error "Expected 745 to be close to 805, 2." in Firefox
+                xit('when CC button is enabled', function () {
+                    var realHeight = parseInt(
+                            $('.subtitles').css('maxHeight'), 10
+                        ),
+                        shouldBeHeight = $('.video-wrapper').height();
+
+                    // Because of some problems with rounding on different
+                    // environments: Linux * Mac * FF * Chrome
+                    expect(realHeight).toBeCloseTo(shouldBeHeight, 2);
+                });
+
+                it('when CC button is disabled ', function () {
+                    var realHeight, videoWrapperHeight, progressSliderHeight,
+                        controlHeight, shouldBeHeight;
+
+                    state.captionsHidden = true;
+                    videoCaption.setSubtitlesHeight();
+
+                    realHeight = parseInt(
+                        $('.subtitles').css('maxHeight'), 10
+                    );
+                    videoWrapperHeight = $('.video-wrapper').height();
+                    progressSliderHeight = videoControl.sliderEl.height();
+                    controlHeight = videoControl.el.height();
+                    shouldBeHeight = videoWrapperHeight -
+                        0.5 * progressSliderHeight -
+                        controlHeight;
+
+                    expect(realHeight).toBe(shouldBeHeight);
+                });
+            });
+
+            it('set the height of caption spacing', function () {
+                var firstSpacing, lastSpacing;
+
+                firstSpacing = Math.abs(parseInt(
+                    $('.subtitles .spacing:first').css('height'), 10
+                ));
+                lastSpacing = Math.abs(parseInt(
+                    $('.subtitles .spacing:last').css('height'), 10
+                ));
+
+                expect(firstSpacing - videoCaption.topSpacingHeight())
+                    .toBeLessThan(1);
+                expect(lastSpacing - videoCaption.bottomSpacingHeight())
+                    .toBeLessThan(1);
+            });
+
+            it('scroll caption to new position', function () {
+                expect($.fn.scrollTo).toHaveBeenCalled();
+            });
+        });
+
+        describe('scrollCaption', function () {
+            beforeEach(function () {
+                initialize();
+            });
+
+            describe('when frozen', function () {
+                beforeEach(function () {
+                    videoCaption.frozen = true;
+                    $('.subtitles li[data-index=1]').addClass('current');
+                    videoCaption.scrollCaption();
+                });
+
+                it('does not scroll the caption', function () {
+                    expect($.fn.scrollTo).not.toHaveBeenCalled();
+                });
+            });
+
+            describe('when not frozen', function () {
+                beforeEach(function () {
+                    videoCaption.frozen = false;
+                });
+
+                describe('when there is no current caption', function () {
+                    beforeEach(function () {
+                        videoCaption.scrollCaption();
+                    });
+
+                    it('does not scroll the caption', function () {
+                        expect($.fn.scrollTo).not.toHaveBeenCalled();
+                    });
+                });
+
+                describe('when there is a current caption', function () {
+                    beforeEach(function () {
+                        $('.subtitles li[data-index=1]').addClass('current');
+                        videoCaption.scrollCaption();
+                    });
+
+                    it('scroll to current caption', function () {
+                        expect($.fn.scrollTo).toHaveBeenCalled();
+                    });
+                });
+            });
+        });
+
+        describe('seekPlayer', function () {
+            describe('when the video speed is 1.0x', function () {
+                beforeEach(function () {
+                    videoSpeedControl.currentSpeed = '1.0';
+                    $('.subtitles li[data-start="14910"]').trigger('click');
+                });
+
+                // Temporarily disabled due to intermittent failures
+                // Fails with error: "InvalidStateError: An attempt was made to
+                // use an object that is not, or is no longer, usable
+                // Expected 0 to equal 14.91."
+                // on Firefox
+                xit('trigger seek event with the correct time', function () {
+                    expect(videoPlayer.currentTime).toEqual(14.91);
+                });
+            });
+
+            describe('when the video speed is not 1.0x', function () {
+                beforeEach(function () {
+                    initialize();
+                    videoSpeedControl.currentSpeed = '0.75';
+                    $('.subtitles li[data-start="14910"]').trigger('click');
+                });
+
+                it('trigger seek event with the correct time', function () {
+                    expect(videoPlayer.currentTime).toEqual(14.91);
+                });
+            });
+
+            describe('when the player type is Flash at speed 0.75x',
+                function () {
+
+                beforeEach(function () {
+                    initialize();
+                    videoSpeedControl.currentSpeed = '0.75';
+                    state.currentPlayerMode = 'flash';
+                    $('.subtitles li[data-start="14910"]').trigger('click');
+                });
+
+                it('trigger seek event with the correct time', function () {
+                    expect(videoPlayer.currentTime).toEqual(15);
+                });
+            });
+        });
+
+        describe('toggle', function () {
+            beforeEach(function () {
+                initialize();
+                spyOn(videoPlayer, 'log');
+                $('.subtitles li[data-index=1]').addClass('current');
+            });
+
+            describe('when the caption is visible', function () {
+                beforeEach(function () {
+                    state.el.removeClass('closed');
+                    videoCaption.toggle(jQuery.Event('click'));
+                });
+
+                it('log the hide_transcript event', function () {
+                    expect(videoPlayer.log).toHaveBeenCalledWith(
+                        'hide_transcript',
+                        {
+                            currentTime: videoPlayer.currentTime
+                        }
+                    );
+                });
+
+                it('hide the caption', function () {
+                    expect(state.el).toHaveClass('closed');
+                });
+            });
+
+            describe('when the caption is hidden', function () {
+                beforeEach(function () {
+                    state.el.addClass('closed');
+                    videoCaption.toggle(jQuery.Event('click'));
+                });
+
+                it('log the show_transcript event', function () {
+                    expect(videoPlayer.log).toHaveBeenCalledWith(
+                        'show_transcript',
+                        {
+                            currentTime: videoPlayer.currentTime
+                        }
+                    );
+                });
+
+                it('show the caption', function () {
+                    expect(state.el).not.toHaveClass('closed');
+                });
+
+                it('scroll the caption', function () {
+                    expect($.fn.scrollTo).toHaveBeenCalled();
+                });
+            });
+        });
+
+        describe('caption accessibility', function () {
+            beforeEach(function () {
+                initialize();
+            });
+
+            describe('when getting focus through TAB key', function () {
+                beforeEach(function () {
+                    videoCaption.isMouseFocus = false;
+                    $('.subtitles li[data-index=0]').trigger(
+                        jQuery.Event('focus')
+                    );
+                });
+
+                it('shows an outline around the caption', function () {
+                    expect($('.subtitles li[data-index=0]'))
+                        .toHaveClass('focused');
+                });
+
+                it('has automatic scrolling disabled', function () {
+                    expect(videoCaption.autoScrolling).toBe(false);
+                });
+            });
+
+            describe('when loosing focus through TAB key', function () {
+                beforeEach(function () {
+                    $('.subtitles li[data-index=0]').trigger(
+                        jQuery.Event('blur')
+                    );
+                });
+
+                it('does not show an outline around the caption', function () {
+                    expect($('.subtitles li[data-index=0]'))
+                        .not.toHaveClass('focused');
+                });
+
+                it('has automatic scrolling enabled', function () {
+                    expect(videoCaption.autoScrolling).toBe(true);
+                });
+            });
+
+            describe(
+                'when same caption gets the focus through mouse after ' +
+                'having focus through TAB key',
+                function () {
+
+                beforeEach(function () {
+                    videoCaption.isMouseFocus = false;
+                    $('.subtitles li[data-index=0]')
+                        .trigger(jQuery.Event('focus'));
+                    $('.subtitles li[data-index=0]')
+                        .trigger(jQuery.Event('mousedown'));
+                });
+
+                it('does not show an outline around it', function () {
+                    expect($('.subtitles li[data-index=0]'))
+                        .not.toHaveClass('focused');
+                });
+
+                it('has automatic scrolling enabled', function () {
+                    expect(videoCaption.autoScrolling).toBe(true);
+                });
+            });
+
+            describe(
+                'when a second caption gets focus through mouse after ' +
+                'first had focus through TAB key',
+                function () {
+
+                var subDataLiIdx__0, subDataLiIdx__1;
+
+                beforeEach(function () {
+                    subDataLiIdx__0 = $('.subtitles li[data-index=0]');
+                    subDataLiIdx__1 = $('.subtitles li[data-index=1]');
+
+                    videoCaption.isMouseFocus = false;
+
+                    subDataLiIdx__0.trigger(jQuery.Event('focus'));
+                    subDataLiIdx__0.trigger(jQuery.Event('blur'));
+
+                    videoCaption.isMouseFocus = true;
+
+                    subDataLiIdx__1.trigger(jQuery.Event('mousedown'));
+                });
+
+                it('does not show an outline around the first', function () {
+                    expect(subDataLiIdx__0).not.toHaveClass('focused');
+                });
+
+                it('does not show an outline around the second', function () {
+                    expect(subDataLiIdx__1).not.toHaveClass('focused');
+                });
+
+                it('has automatic scrolling enabled', function () {
+                    expect(videoCaption.autoScrolling).toBe(true);
+                });
+            });
+
+            xdescribe('when enter key is pressed on a caption', function () {
+                var subDataLiIdx__0;
+
+                beforeEach(function () {
+                    var e;
+
+                    subDataLiIdx__0 = $('.subtitles li[data-index=0]');
+
+                    spyOn(videoCaption, 'seekPlayer').andCallThrough();
+                    videoCaption.isMouseFocus = false;
+                    subDataLiIdx__0.trigger(jQuery.Event('focus'));
+                    e = jQuery.Event('keydown');
+                    e.which = 13; // ENTER key
+                    subDataLiIdx__0.trigger(e);
+                });
+
+                // Temporarily disabled due to intermittent failures.
+                //
+                // Fails with error: "InvalidStateError: InvalidStateError: An
+                // attempt was made to use an object that is not, or is no
+                // longer, usable".
+                xit('shows an outline around it', function () {
+                    expect(subDataLiIdx__0).toHaveClass('focused');
+                });
+
+                xit('calls seekPlayer', function () {
+                    expect(videoCaption.seekPlayer).toHaveBeenCalled();
+                });
+            });
         });
-      });
     });
-  });
 
 }).call(this);
diff --git a/common/lib/xmodule/xmodule/js/src/video/01_initialize.js b/common/lib/xmodule/xmodule/js/src/video/01_initialize.js
index 7f8057c02523..845d79ddb9bd 100644
--- a/common/lib/xmodule/xmodule/js/src/video/01_initialize.js
+++ b/common/lib/xmodule/xmodule/js/src/video/01_initialize.js
@@ -264,15 +264,21 @@ function (VideoPlayer) {
     // The function set initial configuration and preparation.
 
     function initialize(element) {
-        var _this = this, tempYtTestTimeout;
+        var _this = this,
+            regExp = /^true$/i,
+            data, tempYtTestTimeout;
         // This is used in places where we instead would have to check if an
         // element has a CSS class 'fullscreen'.
         this.isFullScreen = false;
 
         // The parent element of the video, and the ID.
         this.el = $(element).find('.video');
+        this.elVideoWrapper = this.el.find('.video-wrapper');
         this.id = this.el.attr('id').replace(/video_/, '');
 
+        // jQuery .data() return object with keys in lower camelCase format.
+        data = this.el.data();
+
         console.log(
             '[Video info]: Initializing video with id "' + this.id + '".'
         );
@@ -283,32 +289,26 @@ function (VideoPlayer) {
         this.config = {
             element: element,
 
-            start:              this.el.data('start'),
-            end:                this.el.data('end'),
-
-            caption_data_dir:   this.el.data('caption-data-dir'),
-            caption_asset_path: this.el.data('caption-asset-path'),
-            show_captions:      (
-                                    this.el.data('show-captions')
-                                        .toString().toLowerCase() === 'true'
-                                ),
-            youtubeStreams:     this.el.data('streams'),
-
-            sub:                this.el.data('sub'),
-            mp4Source:          this.el.data('mp4-source'),
-            webmSource:         this.el.data('webm-source'),
-            oggSource:          this.el.data('ogg-source'),
-
-            ytTestUrl:   this.el.data('yt-test-url'),
-
+            start:              data['start'],
+            end:                data['end'],
+            caption_data_dir:   data['captionDataDir'],
+            caption_asset_path: data['captionAssetPath'],
+            show_captions:      regExp.test(data['showCaptions'].toString()),
+            youtubeStreams:     data['streams'],
+            autohideHtml5:      regExp.test(data['autohideHtml5'].toString()),
+            sub:                data['sub'],
+            mp4Source:          data['mp4Source'],
+            webmSource:         data['webmSource'],
+            oggSource:          data['oggSource'],
+            ytTestUrl:          data['ytTestUrl'],
             fadeOutTimeout:     1400,
-
+            captionsFreezeTime: 10000,
             availableQualities: ['hd720', 'hd1080', 'highres']
         };
 
         // Check if the YT test timeout has been set. If not, or it is in
         // improper format, then set to default value.
-        tempYtTestTimeout = parseInt(this.el.data('yt-test-timeout'), 10);
+        tempYtTestTimeout = parseInt(data['ytTestTimeout'], 10);
         if (!isFinite(tempYtTestTimeout)) {
             tempYtTestTimeout = 1500;
         }
diff --git a/common/lib/xmodule/xmodule/js/src/video/04_video_control.js b/common/lib/xmodule/xmodule/js/src/video/04_video_control.js
index 796ba07060d5..8ba7490cefd9 100644
--- a/common/lib/xmodule/xmodule/js/src/video/04_video_control.js
+++ b/common/lib/xmodule/xmodule/js/src/video/04_video_control.js
@@ -57,7 +57,7 @@ function () {
             state.videoControl.play();
         }
 
-        if (state.videoType === 'html5') {
+        if ((state.videoType === 'html5') && (state.config.autohideHtml5)) {
             state.videoControl.fadeOutTimeout = state.config.fadeOutTimeout;
 
             state.videoControl.el.addClass('html5');
@@ -81,7 +81,7 @@ function () {
         state.videoControl.fullScreenEl.on('click', state.videoControl.toggleFullScreen);
         $(document).on('keyup', state.videoControl.exitFullScreen);
 
-        if (state.videoType === 'html5') {
+        if ((state.videoType === 'html5') && (state.config.autohideHtml5)) {
             state.el.on('mousemove', state.videoControl.showControls);
             state.el.on('keydown', state.videoControl.showControls);
         }
diff --git a/common/lib/xmodule/xmodule/js/src/video/09_video_caption.js b/common/lib/xmodule/xmodule/js/src/video/09_video_caption.js
index b97717e97c54..f69bcc160050 100644
--- a/common/lib/xmodule/xmodule/js/src/video/09_video_caption.js
+++ b/common/lib/xmodule/xmodule/js/src/video/09_video_caption.js
@@ -34,46 +34,63 @@ function () {
 
     // function _makeFunctionsPublic(state)
     //
-    //     Functions which will be accessible via 'state' object. When called, these functions will
-    //     get the 'state' object as a context.
+    //     Functions which will be accessible via 'state' object. When called,
+    //     these functions will get the 'state' object as a context.
     function _makeFunctionsPublic(state) {
-        state.videoCaption.autoShowCaptions        = _.bind(autoShowCaptions, state);
-        state.videoCaption.autoHideCaptions        = _.bind(autoHideCaptions, state);
-        state.videoCaption.resize                  = _.bind(resize, state);
-        state.videoCaption.toggle                  = _.bind(toggle, state);
-        state.videoCaption.onMouseEnter            = _.bind(onMouseEnter, state);
-        state.videoCaption.onMouseLeave            = _.bind(onMouseLeave, state);
-        state.videoCaption.onMovement              = _.bind(onMovement, state);
-        state.videoCaption.renderCaption           = _.bind(renderCaption, state);
-        state.videoCaption.captionHeight           = _.bind(captionHeight, state);
-        state.videoCaption.topSpacingHeight        = _.bind(topSpacingHeight, state);
-        state.videoCaption.bottomSpacingHeight     = _.bind(bottomSpacingHeight, state);
-        state.videoCaption.scrollCaption           = _.bind(scrollCaption, state);
-        state.videoCaption.search                  = _.bind(search, state);
-        state.videoCaption.play                    = _.bind(play, state);
-        state.videoCaption.pause                   = _.bind(pause, state);
-        state.videoCaption.seekPlayer              = _.bind(seekPlayer, state);
-        state.videoCaption.hideCaptions            = _.bind(hideCaptions, state);
-        state.videoCaption.calculateOffset         = _.bind(calculateOffset, state);
-        state.videoCaption.updatePlayTime          = _.bind(updatePlayTime, state);
-        state.videoCaption.setSubtitlesHeight      = _.bind(setSubtitlesHeight, state);
-
-        state.videoCaption.renderElements          = _.bind(renderElements, state);
-        state.videoCaption.bindHandlers            = _.bind(bindHandlers, state);
-        state.videoCaption.fetchCaption            = _.bind(fetchCaption, state);
-        state.videoCaption.captionURL              = _.bind(captionURL, state);
-        state.videoCaption.captionMouseOverOut     = _.bind(captionMouseOverOut, state);
-        state.videoCaption.captionMouseDown        = _.bind(captionMouseDown, state);
-        state.videoCaption.captionClick            = _.bind(captionClick, state);
-        state.videoCaption.captionFocus            = _.bind(captionFocus, state);
-        state.videoCaption.captionBlur             = _.bind(captionBlur, state);
-        state.videoCaption.captionKeyDown          = _.bind(captionKeyDown, state);
+        state.videoCaption.autoShowCaptions    = _.bind(
+            autoShowCaptions, state
+        );
+        state.videoCaption.autoHideCaptions    = _.bind(
+            autoHideCaptions, state
+        );
+        state.videoCaption.resize              = _.bind(resize, state);
+        state.videoCaption.toggle              = _.bind(toggle, state);
+        state.videoCaption.onMouseEnter        = _.bind(onMouseEnter, state);
+        state.videoCaption.onMouseLeave        = _.bind(onMouseLeave, state);
+        state.videoCaption.onMovement          = _.bind(onMovement, state);
+        state.videoCaption.renderCaption       = _.bind(renderCaption, state);
+        state.videoCaption.captionHeight       = _.bind(captionHeight, state);
+        state.videoCaption.topSpacingHeight    = _.bind(
+            topSpacingHeight, state
+        );
+        state.videoCaption.bottomSpacingHeight = _.bind(
+            bottomSpacingHeight, state
+        );
+        state.videoCaption.scrollCaption       = _.bind(scrollCaption, state);
+        state.videoCaption.search              = _.bind(search, state);
+        state.videoCaption.play                = _.bind(play, state);
+        state.videoCaption.pause               = _.bind(pause, state);
+        state.videoCaption.seekPlayer          = _.bind(seekPlayer, state);
+        state.videoCaption.hideCaptions        = _.bind(hideCaptions, state);
+        state.videoCaption.calculateOffset     = _.bind(
+            calculateOffset, state
+        );
+        state.videoCaption.updatePlayTime      = _.bind(updatePlayTime, state);
+        state.videoCaption.setSubtitlesHeight  = _.bind(
+            setSubtitlesHeight, state
+        );
+
+        state.videoCaption.renderElements      = _.bind(renderElements, state);
+        state.videoCaption.bindHandlers        = _.bind(bindHandlers, state);
+        state.videoCaption.fetchCaption        = _.bind(fetchCaption, state);
+        state.videoCaption.captionURL          = _.bind(captionURL, state);
+        state.videoCaption.captionMouseOverOut = _.bind(
+            captionMouseOverOut, state
+        );
+        state.videoCaption.captionMouseDown    = _.bind(
+            captionMouseDown, state
+        );
+        state.videoCaption.captionClick        = _.bind(captionClick, state);
+        state.videoCaption.captionFocus        = _.bind(captionFocus, state);
+        state.videoCaption.captionBlur         = _.bind(captionBlur, state);
+        state.videoCaption.captionKeyDown      = _.bind(captionKeyDown, state);
     }
 
     // ***************************************************************
     // Public functions start here.
-    // These are available via the 'state' object. Their context ('this' keyword) is the 'state' object.
-    // The magic private function that makes them available and sets up their context is makeFunctionsPublic().
+    // These are available via the 'state' object. Their context ('this'
+    // keyword) is the 'state' object. The magic private function that makes
+    // them available and sets up their context is makeFunctionsPublic().
     // ***************************************************************
 
     /**
@@ -109,10 +126,13 @@ function () {
 
     // function bindHandlers()
     //
-    //     Bind any necessary function callbacks to DOM events (click, mousemove, etc.).
+    //     Bind any necessary function callbacks to DOM events (click,
+    //     mousemove, etc.).
     function bindHandlers() {
         $(window).bind('resize', this.videoCaption.resize);
-        this.videoCaption.hideSubtitlesEl.on('click', this.videoCaption.toggle);
+        this.videoCaption.hideSubtitlesEl.on(
+            'click', this.videoCaption.toggle
+        );
 
         this.videoCaption.subtitlesEl
             .on(
@@ -132,14 +152,41 @@ function () {
                 this.videoCaption.onMovement
             );
 
-        if (this.videoType === 'html5') {
-            this.el.on('mousemove', this.videoCaption.autoShowCaptions);
-            this.el.on('keydown', this.videoCaption.autoShowCaptions);
+        if ((this.videoType === 'html5') && (this.config.autohideHtml5)) {
+            this.el.on({
+                mousemove: this.videoCaption.autoShowCaptions,
+                keydown: this.videoCaption.autoShowCaptions
+            });
 
-            // Moving slider on subtitles is not a mouse move,
-            // but captions and controls should be showed.
-            this.videoCaption.subtitlesEl.on('scroll', this.videoCaption.autoShowCaptions);
-            this.videoCaption.subtitlesEl.on('scroll', this.videoControl.showControls);
+            // Moving slider on subtitles is not a mouse move, but captions and
+            // controls should be shown.
+            this.videoCaption.subtitlesEl
+                .on(
+                    'scroll', this.videoCaption.autoShowCaptions
+                )
+                .on(
+                    'scroll', this.videoControl.showControls
+                );
+        } else if (!this.config.autohideHtml5) {
+            this.videoCaption.subtitlesEl.on({
+                keydown: this.videoCaption.autoShowCaptions,
+                focus: this.videoCaption.autoShowCaptions,
+
+                // Moving slider on subtitles is not a mouse move, but captions
+                // should not be auto-hidden.
+                scroll: this.videoCaption.autoShowCaptions,
+
+                mouseout: this.videoCaption.autoHideCaptions,
+                blur: this.videoCaption.autoHideCaptions
+            });
+
+            this.videoCaption.hideSubtitlesEl.on({
+                mousemove: this.videoCaption.autoShowCaptions,
+                focus: this.videoCaption.autoShowCaptions,
+
+                mouseout: this.videoCaption.autoHideCaptions,
+                blur: this.videoCaption.autoHideCaptions
+            });
         }
     }
 
@@ -209,7 +256,8 @@ function () {
     }
 
     function captionURL() {
-        return '' + this.config.caption_asset_path + this.youtubeId('1.0') + '.srt.sjson';
+        return '' + this.config.caption_asset_path +
+            this.youtubeId('1.0') + '.srt.sjson';
     }
 
     function autoShowCaptions(event) {
@@ -224,13 +272,19 @@ function () {
                 this.videoCaption.subtitlesEl.show();
                 this.captionState = 'visible';
             } else if (this.captionState === 'hiding') {
-                this.videoCaption.subtitlesEl.stop(true, false).css('opacity', 1).show();
+                this.videoCaption.subtitlesEl
+                    .stop(true, false).css('opacity', 1).show();
                 this.captionState = 'visible';
             } else if (this.captionState === 'visible') {
                 clearTimeout(this.captionHideTimeout);
             }
 
-            this.captionHideTimeout = setTimeout(this.videoCaption.autoHideCaptions, this.videoCaption.fadeOutTimeout);
+            if (this.config.autohideHtml5) {
+                this.captionHideTimeout = setTimeout(
+                    this.videoCaption.autoHideCaptions,
+                    this.videoCaption.fadeOutTimeout
+                );
+            }
 
             this.captionsShowLock = false;
         }
@@ -249,15 +303,21 @@ function () {
 
         _this = this;
 
-        this.videoCaption.subtitlesEl.fadeOut(this.videoCaption.fadeOutTimeout, function () {
-            _this.captionState = 'invisible';
-        });
+        this.videoCaption.subtitlesEl
+            .fadeOut(
+                this.videoCaption.fadeOutTimeout,
+                function () {
+                    _this.captionState = 'invisible';
+                }
+            );
     }
 
     function resize() {
         this.videoCaption.subtitlesEl
-            .find('.spacing:first').height(this.videoCaption.topSpacingHeight())
-            .find('.spacing:last').height(this.videoCaption.bottomSpacingHeight());
+            .find('.spacing:first')
+            .height(this.videoCaption.topSpacingHeight())
+            .find('.spacing:last')
+            .height(this.videoCaption.bottomSpacingHeight());
 
         this.videoCaption.scrollCaption();
 
@@ -269,7 +329,10 @@ function () {
             clearTimeout(this.videoCaption.frozen);
         }
 
-        this.videoCaption.frozen = setTimeout(this.videoCaption.onMouseLeave, 10000);
+        this.videoCaption.frozen = setTimeout(
+            this.videoCaption.onMouseLeave,
+            this.config.captionsFreezeTime
+        );
     }
 
     function onMouseLeave() {
@@ -285,6 +348,10 @@ function () {
     }
 
     function onMovement() {
+        if (!this.config.autohideHtml5) {
+            this.videoCaption.autoShowCaptions();
+        }
+
         this.videoCaption.onMouseEnter();
     }
 
@@ -292,16 +359,28 @@ function () {
         var container = $('<ol>'),
             _this = this;
 
-        this.el.find('.video-wrapper').after(this.videoCaption.subtitlesEl);
-        this.el.find('.video-controls .secondary-controls').append(this.videoCaption.hideSubtitlesEl);
+        this.elVideoWrapper.after(this.videoCaption.subtitlesEl);
+        this.el.find('.video-controls .secondary-controls')
+            .append(this.videoCaption.hideSubtitlesEl);
 
         this.videoCaption.setSubtitlesHeight();
 
-        if (this.videoType === 'html5') {
+        if ((this.videoType === 'html5') && (this.config.autohideHtml5)) {
             this.videoCaption.fadeOutTimeout = this.config.fadeOutTimeout;
 
             this.videoCaption.subtitlesEl.addClass('html5');
-            this.captionHideTimeout = setTimeout(this.videoCaption.autoHideCaptions, this.videoCaption.fadeOutTimeout);
+            this.captionHideTimeout = setTimeout(
+                this.videoCaption.autoHideCaptions,
+                this.videoCaption.fadeOutTimeout
+            );
+        } else if (!this.config.autohideHtml5) {
+            this.videoCaption.fadeOutTimeout = this.config.fadeOutTimeout;
+            this.videoCaption.subtitlesEl.addClass('html5');
+
+            this.captionHideTimeout = setTimeout(
+                this.videoCaption.autoHideCaptions,
+                0
+            );
         }
 
         this.videoCaption.hideCaptions(this.hide_captions);
@@ -322,38 +401,47 @@ function () {
             container.append(liEl);
         });
 
-        this.videoCaption.subtitlesEl.html(container.html());
-
-        this.videoCaption.subtitlesEl.find('li[data-index]').on({
-            mouseover:  this.videoCaption.captionMouseOverOut,
-            mouseout:   this.videoCaption.captionMouseOverOut,
-            mousedown:  this.videoCaption.captionMouseDown,
-            click:      this.videoCaption.captionClick,
-            focus:      this.videoCaption.captionFocus,
-            blur:       this.videoCaption.captionBlur,
-            keydown:    this.videoCaption.captionKeyDown
-        });
+        this.videoCaption.subtitlesEl
+            .html(container.html())
+            .find('li[data-index]')
+            .on({
+                mouseover:  this.videoCaption.captionMouseOverOut,
+                mouseout:   this.videoCaption.captionMouseOverOut,
+                mousedown:  this.videoCaption.captionMouseDown,
+                click:      this.videoCaption.captionClick,
+                focus:      this.videoCaption.captionFocus,
+                blur:       this.videoCaption.captionBlur,
+                keydown:    this.videoCaption.captionKeyDown
+            });
 
         // Enables or disables automatic scrolling of the captions when the
         // video is playing. This feature has to be disabled when tabbing
         // through them as it interferes with that action. Initially, have this
-        // flag enabled as we assume mouse use. Then, if the first caption 
+        // flag enabled as we assume mouse use. Then, if the first caption
         // (through forward tabbing) or the last caption (through backwards
         // tabbing) gets the focus, disable that feature. Renable it if tabbing
-        // then cycles out of the the captions. 
+        // then cycles out of the the captions.
         this.videoCaption.autoScrolling = true;
         // Keeps track of where the focus is situated in the array of captions.
         // Used to implement the automatic scrolling behavior and decide if the
-        // outline around a caption has to be hidden or shown on a mouseenter or
-        // mouseleave. Initially, no caption has the focus, set the index to -1.
+        // outline around a caption has to be hidden or shown on a mouseenter
+        // or mouseleave. Initially, no caption has the focus, set the
+        // index to -1.
         this.videoCaption.currentCaptionIndex = -1;
-        // Used to track if the focus is coming from a click or tabbing. This 
-        // has to be known to decide if, when a caption gets the focus, an 
+        // Used to track if the focus is coming from a click or tabbing. This
+        // has to be known to decide if, when a caption gets the focus, an
         // outline has to be drawn (tabbing) or not (mouse click).
         this.videoCaption.isMouseFocus = false;
 
-        this.videoCaption.subtitlesEl.prepend($('<li class="spacing">').height(this.videoCaption.topSpacingHeight()));
-        this.videoCaption.subtitlesEl.append($('<li class="spacing">').height(this.videoCaption.bottomSpacingHeight()));
+        this.videoCaption.subtitlesEl
+            .prepend(
+                $('<li class="spacing">')
+                    .height(this.videoCaption.topSpacingHeight())
+            )
+            .append(
+                $('<li class="spacing">')
+                    .height(this.videoCaption.bottomSpacingHeight())
+            );
 
         this.videoCaption.rendered = true;
     }
@@ -362,7 +450,7 @@ function () {
     // On mouseOut, show the outline of a caption that has been tabbed to.
     function captionMouseOverOut(event) {
         var caption = $(event.target),
-            captionIndex = parseInt(caption.attr('data-index'), 10); 
+            captionIndex = parseInt(caption.attr('data-index'), 10);
         if (captionIndex === this.videoCaption.currentCaptionIndex) {
             if (event.type === 'mouseover') {
                 caption.removeClass('focused');
@@ -370,7 +458,7 @@ function () {
             else { // mouseout
                 caption.addClass('focused');
             }
-        } 
+        }
     }
 
     function captionMouseDown(event) {
@@ -390,36 +478,41 @@ function () {
             captionIndex = parseInt(caption.attr('data-index'), 10);
         // If the focus comes from a mouse click, hide the outline, turn on
         // automatic scrolling and set currentCaptionIndex to point outside of
-        // caption list (ie -1) to disable mouseenter, mouseleave behavior. 
+        // caption list (ie -1) to disable mouseenter, mouseleave behavior.
         if (this.videoCaption.isMouseFocus) {
             this.videoCaption.autoScrolling = true;
             caption.removeClass('focused');
             this.videoCaption.currentCaptionIndex = -1;
         }
-        // If the focus comes from tabbing, show the outline and turn off 
+        // If the focus comes from tabbing, show the outline and turn off
         // automatic scrolling.
         else {
             this.videoCaption.currentCaptionIndex = captionIndex;
             caption.addClass('focused');
             // The second and second to last elements turn automatic scrolling
-            // off again as it may have been enabled in captionBlur.    
-            if (captionIndex <= 1 || captionIndex >= this.videoCaption.captions.length-2) {
+            // off again as it may have been enabled in captionBlur.
+            if (
+                captionIndex <= 1 ||
+                captionIndex >= this.videoCaption.captions.length - 2
+            ) {
                 this.videoCaption.autoScrolling = false;
             }
         }
     }
 
     function captionBlur(event) {
-        var caption = $(event.target), 
+        var caption = $(event.target),
             captionIndex = parseInt(caption.attr('data-index'), 10);
         caption.removeClass('focused');
-        // If we are on first or last index, we have to turn automatic scroll on
-        // again when losing focus. There is no way to know in what direction we
-        // are tabbing. So we could be on the first element and tabbing back out
-        // of the captions or on the last element and tabbing forward out of the
-        // captions.
-        if (captionIndex === 0 || 
+        // If we are on first or last index, we have to turn automatic scroll
+        // on again when losing focus. There is no way to know in what
+        // direction we are tabbing. So we could be on the first element and
+        // tabbing back out of the captions or on the last element and tabbing
+        // forward out of the captions.
+        if (captionIndex === 0 ||
             captionIndex === this.videoCaption.captions.length-1) {
+            this.videoCaption.autoHideCaptions();
+
             this.videoCaption.autoScrolling = true;
         }
     }
@@ -434,9 +527,13 @@ function () {
     function scrollCaption() {
         var el = this.videoCaption.subtitlesEl.find('.current:first');
 
-        // Automatic scrolling gets disabled if one of the captions has received 
-        // focus through tabbing. 
-        if (!this.videoCaption.frozen && el.length && this.videoCaption.autoScrolling) {
+        // Automatic scrolling gets disabled if one of the captions has
+        // received focus through tabbing.
+        if (
+            !this.videoCaption.frozen &&
+            el.length &&
+            this.videoCaption.autoScrolling
+        ) {
             this.videoCaption.subtitlesEl.scrollTo(
                 el,
                 {
@@ -565,11 +662,15 @@ function () {
     }
 
     function topSpacingHeight() {
-        return this.videoCaption.calculateOffset(this.videoCaption.subtitlesEl.find('li:not(.spacing):first'));
+        return this.videoCaption.calculateOffset(
+            this.videoCaption.subtitlesEl.find('li:not(.spacing):first')
+        );
     }
 
     function bottomSpacingHeight() {
-        return this.videoCaption.calculateOffset(this.videoCaption.subtitlesEl.find('li:not(.spacing):last'));
+        return this.videoCaption.calculateOffset(
+            this.videoCaption.subtitlesEl.find('li:not(.spacing):last')
+        );
     }
 
     function toggle(event) {
@@ -579,23 +680,45 @@ function () {
             this.videoCaption.hideCaptions(false);
         } else {
             this.videoCaption.hideCaptions(true);
+
+            // In the case when captions are not auto-hidden based on mouse
+            // movement anywhere on the video, we must hide them explicitly
+            // after the "CC" button has been clicked (to hide captions).
+            //
+            // Otherwise, in order for the captions to disappear again, the
+            // user must move the mouse button over the "CC" button, or over
+            // the captions themselves. In this case, an "autoShow" will be
+            // triggered, and after a timeout, an "autoHide".
+            if (!this.config.autohideHtml5) {
+                this.captionHideTimeout = setTimeout(
+                    this.videoCaption.autoHideCaptions(),
+                    0
+                );
+            }
         }
     }
 
-    function hideCaptions(hide_captions) {
-        var type;
+    function hideCaptions(hide_captions, update_cookie) {
+        var hideSubtitlesEl = this.videoCaption.hideSubtitlesEl,
+            type;
 
         if (hide_captions) {
             type = 'hide_transcript';
             this.captionsHidden = true;
-            this.videoCaption.hideSubtitlesEl.attr('title', gettext('Turn on captions'));
-            this.videoCaption.hideSubtitlesEl.text(gettext('Turn on captions'));
+
+            hideSubtitlesEl
+                .attr('title', gettext('Turn on captions'))
+                .text(gettext('Turn on captions'));
+
             this.el.addClass('closed');
         } else {
             type = 'show_transcript';
             this.captionsHidden = false;
-            this.videoCaption.hideSubtitlesEl.attr('title', gettext('Turn off captions'));
-            this.videoCaption.hideSubtitlesEl.text(gettext('Turn off captions'));
+
+            hideSubtitlesEl
+                .attr('title', gettext('Turn off captions'))
+                .text(gettext('Turn off captions'));
+
             this.el.removeClass('closed');
             this.videoCaption.scrollCaption();
         }
@@ -615,27 +738,43 @@ function () {
     }
 
     function captionHeight() {
+        var paddingTop;
+
         if (this.isFullScreen) {
-            return $(window).height() - this.el.find('.video-controls').height() -
-                    0.5 * this.videoControl.sliderEl.height() -
-                    2 * parseInt(this.videoCaption.subtitlesEl.css('padding-top'), 10);
+            paddingTop = parseInt(
+                this.videoCaption.subtitlesEl.css('padding-top'), 10
+            );
+
+            return $(window).height() -
+                this.videoControl.el.height() -
+                0.5 * this.videoControl.sliderEl.height() -
+                2 * paddingTop;
         } else {
-            return this.el.find('.video-wrapper').height();
+            return this.elVideoWrapper.height();
         }
     }
 
     function setSubtitlesHeight() {
         var height = 0;
-        if (this.videoType === 'html5'){
+        if (
+            ((this.videoType === 'html5') && (this.config.autohideHtml5)) ||
+            (!this.config.autohideHtml5)
+        ){
             // on page load captionHidden = undefined
             if  (
-                (this.captionsHidden === undefined && this.hide_captions === true ) ||
-                (this.captionsHidden === true) ) {
-                // In case of html5 autoshowing subtitles,
-                // we ajdust height of subs, by height of scrollbar
-                height = this.videoControl.el.height() + 0.5 * this.videoControl.sliderEl.height();
-                // height of videoControl does not contain height of slider.
-                // (css is set to absolute, to avoid yanking when slider autochanges its height)
+                (
+                    this.captionsHidden === undefined &&
+                    this.hide_captions === true
+                ) ||
+                (this.captionsHidden === true)
+            ) {
+                // In case of html5 autoshowing subtitles, we adjust height of
+                // subs, by height of scrollbar.
+                height = this.videoControl.el.height() +
+                    0.5 * this.videoControl.sliderEl.height();
+                // Height of videoControl does not contain height of slider.
+                // css is set to absolute, to avoid yanking when slider
+                // autochanges its height.
             }
         }
         this.videoCaption.subtitlesEl.css({
diff --git a/common/lib/xmodule/xmodule/lti_module.py b/common/lib/xmodule/xmodule/lti_module.py
index e2c483225199..cd330ab9a20e 100644
--- a/common/lib/xmodule/xmodule/lti_module.py
+++ b/common/lib/xmodule/xmodule/lti_module.py
@@ -10,6 +10,7 @@
 import urllib
 
 from xmodule.editing_module import MetadataOnlyEditingDescriptor
+from xmodule.raw_module import EmptyDataRawDescriptor
 from xmodule.x_module import XModule
 from xmodule.course_module import CourseDescriptor
 from pkg_resources import resource_string
@@ -254,8 +255,8 @@ def oauth_params(self, custom_parameters, client_key, client_secret):
         return params
 
 
-class LTIModuleDescriptor(LTIFields, MetadataOnlyEditingDescriptor):
+class LTIModuleDescriptor(LTIFields, MetadataOnlyEditingDescriptor, EmptyDataRawDescriptor):
     """
-    LTIModuleDescriptor provides no export/import to xml.
+    Descriptor for LTI Xmodule.
     """
     module_class = LTIModule
diff --git a/common/lib/xmodule/xmodule/modulestore/mongo/draft.py b/common/lib/xmodule/xmodule/modulestore/mongo/draft.py
index b816ab246dc0..f7a025015552 100644
--- a/common/lib/xmodule/xmodule/modulestore/mongo/draft.py
+++ b/common/lib/xmodule/xmodule/modulestore/mongo/draft.py
@@ -234,12 +234,26 @@ def publish(self, location, published_by_id):
         """
         Save a current draft to the underlying modulestore
         """
+        try:
+            original_published = super(DraftModuleStore, self).get_item(location)
+        except ItemNotFoundError:
+            original_published = None
+
         draft = self.get_item(location)
 
         draft.published_date = datetime.now(UTC)
         draft.published_by = published_by_id
         super(DraftModuleStore, self).update_item(location, draft.get_explicitly_set_fields_by_scope(Scope.content))
         if draft.has_children:
+            if original_published is not None:
+                # see if children were deleted. 2 reasons for children lists to differ:
+                #   1) child deleted
+                #   2) child moved
+                for child in original_published.children:
+                    if child not in draft.children:
+                        rents = [Location(mom) for mom in self.get_parent_locations(child, None)]
+                        if (len(rents) == 1 and rents[0] == Location(location)):  # the 1 is this original_published
+                            self.delete_item(child, True)
             super(DraftModuleStore, self).update_children(location, draft.children)
         super(DraftModuleStore, self).update_metadata(location, own_metadata(draft))
         self.delete_item(location)
diff --git a/common/lib/xmodule/xmodule/modulestore/tests/test_publish.py b/common/lib/xmodule/xmodule/modulestore/tests/test_publish.py
new file mode 100644
index 000000000000..3b535c673801
--- /dev/null
+++ b/common/lib/xmodule/xmodule/modulestore/tests/test_publish.py
@@ -0,0 +1,189 @@
+"""
+Test the publish code (primary causing orphans)
+"""
+import uuid
+import mock
+import unittest
+import datetime
+import random
+
+from xmodule.modulestore.inheritance import InheritanceMixin
+from xmodule.modulestore.mongo import MongoModuleStore, DraftMongoModuleStore
+from xmodule.modulestore import Location
+from xmodule.fields import Date
+from xmodule.modulestore.exceptions import ItemNotFoundError
+from xmodule.modulestore.mongo.draft import DIRECT_ONLY_CATEGORIES
+
+
+class TestPublish(unittest.TestCase):
+    """
+    Test the publish code (primary causing orphans)
+    """
+
+    # Snippet of what would be in the django settings envs file
+    db_config = {
+        'host': 'localhost',
+        'db': 'test_xmodule',
+    }
+
+    modulestore_options = dict({
+        'default_class': 'xmodule.raw_module.RawDescriptor',
+        'fs_root': '',
+        'render_template': mock.Mock(return_value=""),
+        'xblock_mixins': (InheritanceMixin,)
+    }, **db_config)
+
+    def setUp(self):
+        self.modulestore_options['collection'] = 'modulestore{0}'.format(uuid.uuid4().hex)
+
+        self.old_mongo = MongoModuleStore(**self.modulestore_options)
+        self.draft_mongo = DraftMongoModuleStore(**self.modulestore_options)
+        self.addCleanup(self.tear_down_mongo)
+        self.course_location = None
+
+    def tear_down_mongo(self):
+        # old_mongo doesn't give a db attr, but all of the dbs are the same and draft and pub use same collection
+        dbref = self.old_mongo.collection.database
+        dbref.drop_collection(self.old_mongo.collection)
+        dbref.connection.close()
+
+    def _create_item(self, category, name, data, metadata, parent_category, parent_name, runtime):
+        """
+        Create the item in either draft or direct based on category and attach to its parent.
+        """
+        location = self.course_location.replace(category=category, name=name)
+        if category in DIRECT_ONLY_CATEGORIES:
+            mongo = self.old_mongo
+        else:
+            mongo = self.draft_mongo
+        mongo.create_and_save_xmodule(location, data, metadata, runtime)
+        if isinstance(data, basestring):
+            fields = {'data': data}
+        else:
+            fields = data.copy()
+        fields.update(metadata)
+        if parent_name:
+            # add child to parent in mongo
+            parent_location = self.course_location.replace(category=parent_category, name=parent_name)
+            parent = self.draft_mongo.get_item(parent_location)
+            parent.children.append(location.url())
+            if parent_category in DIRECT_ONLY_CATEGORIES:
+                mongo = self.old_mongo
+            else:
+                mongo = self.draft_mongo
+            mongo.update_children(parent_location, parent.children)
+
+    def _create_course(self):
+        """
+        Create the course, publish all verticals
+        * some detached items
+        """
+        date_proxy = Date()
+        metadata = {
+            'start': date_proxy.to_json(datetime.datetime(2000, 3, 13, 4)),
+            'display_name': 'Migration test course',
+        }
+        data = {
+            'wiki_slug': 'test_course_slug'
+        }
+        fields = metadata.copy()
+        fields.update(data)
+
+        self.course_location = Location('i4x', 'test_org', 'test_course', 'course', 'runid')
+        self.old_mongo.create_and_save_xmodule(self.course_location, data, metadata)
+        runtime = self.draft_mongo.get_item(self.course_location).runtime
+
+        self._create_item('chapter', 'Chapter1', {}, {'display_name': 'Chapter 1'}, 'course', 'runid', runtime)
+        self._create_item('chapter', 'Chapter2', {}, {'display_name': 'Chapter 2'}, 'course', 'runid', runtime)
+        self._create_item('vertical', 'Vert1', {}, {'display_name': 'Vertical 1'}, 'chapter', 'Chapter1', runtime)
+        self._create_item('vertical', 'Vert2', {}, {'display_name': 'Vertical 2'}, 'chapter', 'Chapter1', runtime)
+        self._create_item('html', 'Html1', "<p>Goodbye</p>", {'display_name': 'Parented Html'}, 'vertical', 'Vert1', runtime)
+        self._create_item(
+            'discussion', 'Discussion1',
+            "discussion discussion_category=\"Lecture 1\" discussion_id=\"a08bfd89b2aa40fa81f2c650a9332846\" discussion_target=\"Lecture 1\"/>\n",
+            {
+                "discussion_category": "Lecture 1",
+                "discussion_target": "Lecture 1",
+                "display_name": "Lecture 1 Discussion",
+                "discussion_id": "a08bfd89b2aa40fa81f2c650a9332846"
+            },
+            'vertical', 'Vert1', runtime
+        )
+        self._create_item('html', 'Html2', "<p>Hellow</p>", {'display_name': 'Hollow Html'}, 'vertical', 'Vert1', runtime)
+        self._create_item(
+            'discussion', 'Discussion2',
+            "discussion discussion_category=\"Lecture 2\" discussion_id=\"b08bfd89b2aa40fa81f2c650a9332846\" discussion_target=\"Lecture 2\"/>\n",
+            {
+                "discussion_category": "Lecture 2",
+                "discussion_target": "Lecture 2",
+                "display_name": "Lecture 2 Discussion",
+                "discussion_id": "b08bfd89b2aa40fa81f2c650a9332846"
+            },
+            'vertical', 'Vert2', runtime
+        )
+        self._create_item('static_tab', 'staticuno', "<p>tab</p>", {'display_name': 'Tab uno'}, None, None, runtime)
+        self._create_item('about', 'overview', "<p>overview</p>", {}, None, None, runtime)
+        self._create_item('course_info', 'updates', "<ol><li><h2>Sep 22</h2><p>test</p></li></ol>", {}, None, None, runtime)
+
+    def _xmodule_recurse(self, item, action):
+        """
+        Applies action depth-first down tree and to item last.
+
+        A copy of  cms.djangoapps.contentstore.views.requests._xmodule_recurse to reproduce its use and behavior
+        outside of django.
+        """
+        for child in item.get_children():
+            self._xmodule_recurse(child, action)
+
+        action(item)
+
+    def test_publish_draft_delete(self):
+        """
+        To reproduce a bug (STUD-811) publish a vertical, convert to draft, delete a child, move a child, publish.
+        See if deleted and moved children still is connected or exists in db (bug was disconnected but existed)
+        """
+        self._create_course()
+        userid = random.getrandbits(32)
+        location = self.course_location.replace(category='vertical', name='Vert1')
+        item = self.draft_mongo.get_item(location, 2)
+        self._xmodule_recurse(
+            item,
+            lambda i: self.draft_mongo.publish(i.location, userid)
+        )
+        # verify status
+        item = self.draft_mongo.get_item(location, 0)
+        self.assertFalse(getattr(item, 'is_draft', False), "Item was published. Draft should not exist")
+        # however, children are still draft, but I'm not sure that's by design
+
+        # convert back to draft
+        self.draft_mongo.convert_to_draft(location)
+        # both draft and published should exist
+        draft_vert = self.draft_mongo.get_item(location, 0)
+        self.assertTrue(getattr(draft_vert, 'is_draft', False), "Item was converted to draft but doesn't say so")
+        item = self.old_mongo.get_item(location, 0)
+        self.assertFalse(getattr(item, 'is_draft', False), "Published item doesn't say so")
+
+        # delete the discussion (which oddly is not in draft mode)
+        location = self.course_location.replace(category='discussion', name='Discussion1')
+        self.draft_mongo.delete_item(location)
+        # remove pointer from draft vertical (verify presence first to ensure process is valid)
+        self.assertIn(location.url(), draft_vert.children)
+        draft_vert.children.remove(location.url())
+        # move the other child
+        other_child_loc = self.course_location.replace(category='html', name='Html2')
+        draft_vert.children.remove(other_child_loc.url())
+        other_vert = self.draft_mongo.get_item(self.course_location.replace(category='vertical', name='Vert2'), 0)
+        other_vert.children.append(other_child_loc.url())
+        self.draft_mongo.update_children(draft_vert.location, draft_vert.children)
+        self.draft_mongo.update_children(other_vert.location, other_vert.children)
+        # publish
+        self._xmodule_recurse(
+            draft_vert,
+            lambda i: self.draft_mongo.publish(i.location, userid)
+        )
+        item = self.old_mongo.get_item(draft_vert.location, 0)
+        self.assertNotIn(location.url(), item.children)
+        with self.assertRaises(ItemNotFoundError):
+            self.draft_mongo.get_item(location)
+        self.assertNotIn(other_child_loc.url(), item.children)
+        self.assertTrue(self.draft_mongo.has_item(None, other_child_loc), "Oops, lost moved item")
diff --git a/lms/djangoapps/bulk_email/admin.py b/lms/djangoapps/bulk_email/admin.py
index 3550e1eb4200..f4529a9e70db 100644
--- a/lms/djangoapps/bulk_email/admin.py
+++ b/lms/djangoapps/bulk_email/admin.py
@@ -3,8 +3,8 @@
 """
 from django.contrib import admin
 
-from bulk_email.models import CourseEmail, Optout, CourseEmailTemplate
-from bulk_email.forms import CourseEmailTemplateForm
+from bulk_email.models import CourseEmail, Optout, CourseEmailTemplate, CourseAuthorization
+from bulk_email.forms import CourseEmailTemplateForm, CourseAuthorizationAdminForm
 
 
 class CourseEmailAdmin(admin.ModelAdmin):
@@ -57,6 +57,23 @@ def has_delete_permission(self, request, obj=None):
         return False
 
 
+class CourseAuthorizationAdmin(admin.ModelAdmin):
+    """Admin for enabling email on a course-by-course basis."""
+    form = CourseAuthorizationAdminForm
+    fieldsets = (
+        (None, {
+            'fields': ('course_id', 'email_enabled'),
+            'description': '''
+Enter a course id in the following form: Org/Course/CourseRun, eg MITx/6.002x/2012_Fall
+Do not enter leading or trailing slashes. There is no need to surround the course ID with quotes.
+Validation will be performed on the course name, and if it is invalid, an error message will display.
+
+To enable email for the course, check the "Email enabled" box, then click "Save".
+'''
+        }),
+    )
+
 admin.site.register(CourseEmail, CourseEmailAdmin)
 admin.site.register(Optout, OptoutAdmin)
 admin.site.register(CourseEmailTemplate, CourseEmailTemplateAdmin)
+admin.site.register(CourseAuthorization, CourseAuthorizationAdmin)
diff --git a/lms/djangoapps/bulk_email/forms.py b/lms/djangoapps/bulk_email/forms.py
index fc75d4e4b642..bec05fba52c6 100644
--- a/lms/djangoapps/bulk_email/forms.py
+++ b/lms/djangoapps/bulk_email/forms.py
@@ -6,12 +6,16 @@
 from django import forms
 from django.core.exceptions import ValidationError
 
-from bulk_email.models import CourseEmailTemplate, COURSE_EMAIL_MESSAGE_BODY_TAG
+from bulk_email.models import CourseEmailTemplate, COURSE_EMAIL_MESSAGE_BODY_TAG, CourseAuthorization
+
+from courseware.courses import get_course_by_id
+from xmodule.modulestore import MONGO_MODULESTORE_TYPE
+from xmodule.modulestore.django import modulestore
 
 log = logging.getLogger(__name__)
 
 
-class CourseEmailTemplateForm(forms.ModelForm):
+class CourseEmailTemplateForm(forms.ModelForm):  # pylint: disable=R0924
     """Form providing validation of CourseEmail templates."""
 
     class Meta:  # pylint: disable=C0111
@@ -43,3 +47,32 @@ def clean_plain_template(self):
         template = self.cleaned_data["plain_template"]
         self._validate_template(template)
         return template
+
+
+class CourseAuthorizationAdminForm(forms.ModelForm):  # pylint: disable=R0924
+    """Input form for email enabling, allowing us to verify data."""
+
+    class Meta:  # pylint: disable=C0111
+        model = CourseAuthorization
+
+    def clean_course_id(self):
+        """Validate the course id"""
+        course_id = self.cleaned_data["course_id"]
+        try:
+            # Just try to get the course descriptor.
+            # If we can do that, it's a real course.
+            get_course_by_id(course_id, depth=1)
+        except Exception as exc:
+            msg = 'Error encountered ({0})'.format(str(exc).capitalize())
+            msg += ' --- Entered course id was: "{0}". '.format(course_id)
+            msg += 'Please recheck that you have supplied a course id in the format: ORG/COURSE/RUN'
+            raise forms.ValidationError(msg)
+
+        # Now, try and discern if it is a Studio course - HTML editor doesn't work with XML courses
+        is_studio_course = modulestore().get_modulestore_type(course_id) == MONGO_MODULESTORE_TYPE
+        if not is_studio_course:
+            msg = "Course Email feature is only available for courses authored in Studio. "
+            msg += '"{0}" appears to be an XML backed course.'.format(course_id)
+            raise forms.ValidationError(msg)
+
+        return course_id
diff --git a/lms/djangoapps/bulk_email/migrations/0008_add_course_authorizations.py b/lms/djangoapps/bulk_email/migrations/0008_add_course_authorizations.py
new file mode 100644
index 000000000000..b200ea2bde9e
--- /dev/null
+++ b/lms/djangoapps/bulk_email/migrations/0008_add_course_authorizations.py
@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+import datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Adding model 'CourseAuthorization'
+        db.create_table('bulk_email_courseauthorization', (
+            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
+            ('course_id', self.gf('django.db.models.fields.CharField')(max_length=255, db_index=True)),
+            ('email_enabled', self.gf('django.db.models.fields.BooleanField')(default=False)),
+        ))
+        db.send_create_signal('bulk_email', ['CourseAuthorization'])
+
+
+    def backwards(self, orm):
+        # Deleting model 'CourseAuthorization'
+        db.delete_table('bulk_email_courseauthorization')
+
+
+    models = {
+        'auth.group': {
+            'Meta': {'object_name': 'Group'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
+            'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
+        },
+        'auth.permission': {
+            'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'},
+            'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
+        },
+        'auth.user': {
+            'Meta': {'object_name': 'User'},
+            'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
+            'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
+            'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
+            'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
+        },
+        'bulk_email.courseauthorization': {
+            'Meta': {'object_name': 'CourseAuthorization'},
+            'course_id': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'}),
+            'email_enabled': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
+        },
+        'bulk_email.courseemail': {
+            'Meta': {'object_name': 'CourseEmail'},
+            'course_id': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
+            'html_message': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
+            'sender': ('django.db.models.fields.related.ForeignKey', [], {'default': '1', 'to': "orm['auth.User']", 'null': 'True', 'blank': 'True'}),
+            'slug': ('django.db.models.fields.CharField', [], {'max_length': '128', 'db_index': 'True'}),
+            'subject': ('django.db.models.fields.CharField', [], {'max_length': '128', 'blank': 'True'}),
+            'text_message': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
+            'to_option': ('django.db.models.fields.CharField', [], {'default': "'myself'", 'max_length': '64'})
+        },
+        'bulk_email.courseemailtemplate': {
+            'Meta': {'object_name': 'CourseEmailTemplate'},
+            'html_template': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'plain_template': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'})
+        },
+        'bulk_email.optout': {
+            'Meta': {'unique_together': "(('user', 'course_id'),)", 'object_name': 'Optout'},
+            'course_id': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']", 'null': 'True'})
+        },
+        'contenttypes.contenttype': {
+            'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
+            'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
+        }
+    }
+
+    complete_apps = ['bulk_email']
\ No newline at end of file
diff --git a/lms/djangoapps/bulk_email/models.py b/lms/djangoapps/bulk_email/models.py
index 9d32dbd70c0b..83a691f18e3c 100644
--- a/lms/djangoapps/bulk_email/models.py
+++ b/lms/djangoapps/bulk_email/models.py
@@ -12,11 +12,21 @@
 
 """
 import logging
-from django.db import models
+from django.db import models, transaction
 from django.contrib.auth.models import User
+from html_to_text import html_to_text
+
+from django.conf import settings
 
 log = logging.getLogger(__name__)
 
+# Bulk email to_options - the send to options that users can
+# select from when they send email.
+SEND_TO_MYSELF = 'myself'
+SEND_TO_STAFF = 'staff'
+SEND_TO_ALL = 'all'
+TO_OPTIONS = [SEND_TO_MYSELF, SEND_TO_STAFF, SEND_TO_ALL]
+
 
 class Email(models.Model):
     """
@@ -33,12 +43,8 @@ class Email(models.Model):
     class Meta:  # pylint: disable=C0111
         abstract = True
 
-SEND_TO_MYSELF = 'myself'
-SEND_TO_STAFF = 'staff'
-SEND_TO_ALL = 'all'
-
 
-class CourseEmail(Email, models.Model):
+class CourseEmail(Email):
     """
     Stores information for an email to a course.
     """
@@ -51,17 +57,66 @@ class CourseEmail(Email, models.Model):
     # * All: This sends an email to anyone enrolled in the course, with any role
     #   (student, staff, or instructor)
     #
-    TO_OPTIONS = (
+    TO_OPTION_CHOICES = (
         (SEND_TO_MYSELF, 'Myself'),
         (SEND_TO_STAFF, 'Staff and instructors'),
         (SEND_TO_ALL, 'All')
     )
     course_id = models.CharField(max_length=255, db_index=True)
-    to_option = models.CharField(max_length=64, choices=TO_OPTIONS, default=SEND_TO_MYSELF)
+    to_option = models.CharField(max_length=64, choices=TO_OPTION_CHOICES, default=SEND_TO_MYSELF)
 
     def __unicode__(self):
         return self.subject
 
+    @classmethod
+    def create(cls, course_id, sender, to_option, subject, html_message, text_message=None):
+        """
+        Create an instance of CourseEmail.
+
+        The CourseEmail.save_now method makes sure the CourseEmail entry is committed.
+        When called from any view that is wrapped by TransactionMiddleware,
+        and thus in a "commit-on-success" transaction, an autocommit buried within here
+        will cause any pending transaction to be committed by a successful
+        save here.  Any future database operations will take place in a
+        separate transaction.
+        """
+        # automatically generate the stripped version of the text from the HTML markup:
+        if text_message is None:
+            text_message = html_to_text(html_message)
+
+        # perform some validation here:
+        if to_option not in TO_OPTIONS:
+            fmt = 'Course email being sent to unrecognized to_option: "{to_option}" for "{course}", subject "{subject}"'
+            msg = fmt.format(to_option=to_option, course=course_id, subject=subject)
+            raise ValueError(msg)
+
+        # create the task, then save it immediately:
+        course_email = cls(
+            course_id=course_id,
+            sender=sender,
+            to_option=to_option,
+            subject=subject,
+            html_message=html_message,
+            text_message=text_message,
+        )
+        course_email.save_now()
+
+        return course_email
+
+    @transaction.autocommit
+    def save_now(self):
+        """
+        Writes CourseEmail immediately, ensuring the transaction is committed.
+
+        Autocommit annotation makes sure the database entry is committed.
+        When called from any view that is wrapped by TransactionMiddleware,
+        and thus in a "commit-on-success" transaction, this autocommit here
+        will cause any pending transaction to be committed by a successful
+        save here.  Any future database operations will take place in a
+        separate transaction.
+        """
+        self.save()
+
 
 class Optout(models.Model):
     """
@@ -101,7 +156,11 @@ def get_template():
 
         If one isn't stored, an exception is thrown.
         """
-        return CourseEmailTemplate.objects.get()
+        try:
+            return CourseEmailTemplate.objects.get()
+        except CourseEmailTemplate.DoesNotExist:
+            log.exception("Attempting to fetch a non-existent course email template")
+            raise
 
     @staticmethod
     def _render(format_string, message_body, context):
@@ -153,3 +212,38 @@ def render_htmltext(self, htmltext, context):
         stored HTML template and the provided `context` dict.
         """
         return CourseEmailTemplate._render(self.html_template, htmltext, context)
+
+
+class CourseAuthorization(models.Model):
+    """
+    Enable the course email feature on a course-by-course basis.
+    """
+    # The course that these features are attached to.
+    course_id = models.CharField(max_length=255, db_index=True)
+
+    # Whether or not to enable instructor email
+    email_enabled = models.BooleanField(default=False)
+
+    @classmethod
+    def instructor_email_enabled(cls, course_id):
+        """
+        Returns whether or not email is enabled for the given course id.
+
+        If email has not been explicitly enabled, returns False.
+        """
+        # If settings.MITX_FEATURES['REQUIRE_COURSE_EMAIL_AUTH'] is
+        # set to False, then we enable email for every course.
+        if not settings.MITX_FEATURES['REQUIRE_COURSE_EMAIL_AUTH']:
+            return True
+
+        try:
+            record = cls.objects.get(course_id=course_id)
+            return record.email_enabled
+        except cls.DoesNotExist:
+            return False
+
+    def __unicode__(self):
+        not_en = "Not "
+        if self.email_enabled:
+            not_en = ""
+        return u"Course '{}': Instructor Email {}Enabled".format(self.course_id, not_en)
diff --git a/lms/djangoapps/bulk_email/tasks.py b/lms/djangoapps/bulk_email/tasks.py
index 1f15a8b4d727..a2f376cdcc5a 100644
--- a/lms/djangoapps/bulk_email/tasks.py
+++ b/lms/djangoapps/bulk_email/tasks.py
@@ -4,174 +4,500 @@
 """
 import math
 import re
-import time
+import random
+import json
+from uuid import uuid4
+from time import sleep
 
 from dogapi import dog_stats_api
-from smtplib import SMTPServerDisconnected, SMTPDataError, SMTPConnectError
+from smtplib import SMTPServerDisconnected, SMTPDataError, SMTPConnectError, SMTPException
+from boto.ses.exceptions import (
+    SESDailyQuotaExceededError,
+    SESMaxSendingRateExceededError,
+    SESAddressBlacklistedError,
+    SESIllegalAddressError,
+    SESLocalAddressCharacterError,
+)
+from boto.exception import AWSConnectionError
+
+from celery import task, current_task, group
+from celery.utils.log import get_task_logger
+from celery.states import SUCCESS, FAILURE, RETRY
+from celery.exceptions import RetryTaskError
 
 from django.conf import settings
 from django.contrib.auth.models import User, Group
 from django.core.mail import EmailMultiAlternatives, get_connection
-from django.http import Http404
-from celery import task, current_task
-from celery.utils.log import get_task_logger
 from django.core.urlresolvers import reverse
 
 from bulk_email.models import (
     CourseEmail, Optout, CourseEmailTemplate,
-    SEND_TO_MYSELF, SEND_TO_STAFF, SEND_TO_ALL,
+    SEND_TO_MYSELF, SEND_TO_ALL, TO_OPTIONS,
 )
 from courseware.access import _course_staff_group_name, _course_instructor_group_name
-from courseware.courses import get_course_by_id, course_image_url
+from courseware.courses import get_course, course_image_url
+from instructor_task.models import InstructorTask
+from instructor_task.subtasks import (
+    update_subtask_status,
+    create_subtask_status,
+    increment_subtask_status,
+    initialize_subtask_info,
+    check_subtask_is_valid,
+)
 
 log = get_task_logger(__name__)
 
 
-@task(default_retry_delay=10, max_retries=5)  # pylint: disable=E1102
-def delegate_email_batches(email_id, user_id):
-    """
-    Delegates emails by querying for the list of recipients who should
-    get the mail, chopping up into batches of settings.EMAILS_PER_TASK size,
-    and queueing up worker jobs.
+# Errors that an individual email is failing to be sent, and should just
+# be treated as a fail.
+SINGLE_EMAIL_FAILURE_ERRORS = (SESAddressBlacklistedError, SESIllegalAddressError, SESLocalAddressCharacterError)
 
-    Returns the number of batches (workers) kicked off.
-    """
-    try:
-        email_obj = CourseEmail.objects.get(id=email_id)
-    except CourseEmail.DoesNotExist as exc:
-        # The retry behavior here is necessary because of a race condition between the commit of the transaction
-        # that creates this CourseEmail row and the celery pipeline that starts this task.
-        # We might possibly want to move the blocking into the view function rather than have it in this task.
-        log.warning("Failed to get CourseEmail with id %s, retry %d", email_id, current_task.request.retries)
-        raise delegate_email_batches.retry(arg=[email_id, user_id], exc=exc)
+# Exceptions that, if caught, should cause the task to be re-tried.
+# These errors will be caught a limited number of times before the task fails.
+LIMITED_RETRY_ERRORS = (SMTPConnectError, SMTPServerDisconnected, AWSConnectionError)
 
-    to_option = email_obj.to_option
-    course_id = email_obj.course_id
+# Errors that indicate that a mailing task should be retried without limit.
+# An example is if email is being sent too quickly, but may succeed if sent
+# more slowly.  When caught by a task, it triggers an exponential backoff and retry.
+# Retries happen continuously until the email is sent.
+# Note that the SMTPDataErrors here are only those within the 4xx range.
+# Those not in this range (i.e. in the 5xx range) are treated as hard failures
+# and thus like SINGLE_EMAIL_FAILURE_ERRORS.
+INFINITE_RETRY_ERRORS = (SESMaxSendingRateExceededError, SMTPDataError)
 
-    try:
-        course = get_course_by_id(course_id, depth=1)
-    except Http404 as exc:
-        log.exception("get_course_by_id failed: %s", exc.args[0])
-        raise Exception("get_course_by_id failed: " + exc.args[0])
+# Errors that are known to indicate an inability to send any more emails,
+# and should therefore not be retried.  For example, exceeding a quota for emails.
+# Also, any SMTP errors that are not explicitly enumerated above.
+BULK_EMAIL_FAILURE_ERRORS = (SESDailyQuotaExceededError, SMTPException)
 
-    course_url = 'https://{}{}'.format(
-        settings.SITE_NAME,
-        reverse('course_root', kwargs={'course_id': course_id})
-    )
-    image_url = 'https://{}{}'.format(settings.SITE_NAME, course_image_url(course))
+
+def _get_recipient_queryset(user_id, to_option, course_id, course_location):
+    """
+    Returns a query set of email recipients corresponding to the requested to_option category.
+
+    `to_option` is either SEND_TO_MYSELF, SEND_TO_STAFF, or SEND_TO_ALL.
+
+    Recipients who are in more than one category (e.g. enrolled in the course and are staff or self)
+    will be properly deduped.
+    """
+    if to_option not in TO_OPTIONS:
+        log.error("Unexpected bulk email TO_OPTION found: %s", to_option)
+        raise Exception("Unexpected bulk email TO_OPTION found: {0}".format(to_option))
 
     if to_option == SEND_TO_MYSELF:
         recipient_qset = User.objects.filter(id=user_id)
-    elif to_option == SEND_TO_ALL or to_option == SEND_TO_STAFF:
-        staff_grpname = _course_staff_group_name(course.location)
+    else:
+        staff_grpname = _course_staff_group_name(course_location)
         staff_group, _ = Group.objects.get_or_create(name=staff_grpname)
         staff_qset = staff_group.user_set.all()
-        instructor_grpname = _course_instructor_group_name(course.location)
+        instructor_grpname = _course_instructor_group_name(course_location)
         instructor_group, _ = Group.objects.get_or_create(name=instructor_grpname)
         instructor_qset = instructor_group.user_set.all()
         recipient_qset = staff_qset | instructor_qset
-
         if to_option == SEND_TO_ALL:
-            enrollment_qset = User.objects.filter(courseenrollment__course_id=course_id,
-                                                  courseenrollment__is_active=True)
+            # We also require students to have activated their accounts to
+            # provide verification that the provided email address is valid.
+            enrollment_qset = User.objects.filter(
+                is_active=True,
+                courseenrollment__course_id=course_id,
+                courseenrollment__is_active=True
+            )
             recipient_qset = recipient_qset | enrollment_qset
         recipient_qset = recipient_qset.distinct()
-    else:
-        log.error("Unexpected bulk email TO_OPTION found: %s", to_option)
-        raise Exception("Unexpected bulk email TO_OPTION found: {0}".format(to_option))
 
     recipient_qset = recipient_qset.order_by('pk')
+    return recipient_qset
+
+
+def _get_course_email_context(course):
+    """
+    Returns context arguments to apply to all emails, independent of recipient.
+    """
+    course_id = course.id
+    course_title = course.display_name
+    course_url = 'https://{}{}'.format(
+        settings.SITE_NAME,
+        reverse('course_root', kwargs={'course_id': course_id})
+    )
+    image_url = 'https://{}{}'.format(settings.SITE_NAME, course_image_url(course))
+    email_context = {
+        'course_title': course_title,
+        'course_url': course_url,
+        'course_image_url': image_url,
+        'account_settings_url': 'https://{}{}'.format(settings.SITE_NAME, reverse('dashboard')),
+        'platform_name': settings.PLATFORM_NAME,
+    }
+    return email_context
+
+
+def _generate_subtasks(create_subtask_fcn, recipient_qset):
+    """
+    Generates a list of subtasks to send email to a given set of recipients.
+
+    Arguments:
+        `create_subtask_fcn` : a function whose inputs are a list of recipients and a subtask_id
+            to assign to the new subtask.  Returns the subtask that will send email to that
+            list of recipients.
+        `recipient_qset` : a query set that defines the recipients who should receive emails.
+
+    Returns:  a tuple, containing:
+
+      * A list of subtasks that will send emails to all recipients.
+      * A list of subtask_ids corresponding to those subtasks.
+      * A count of the total number of emails being sent.
+
+    """
     total_num_emails = recipient_qset.count()
-    num_queries = int(math.ceil(float(total_num_emails) / float(settings.EMAILS_PER_QUERY)))
+    num_queries = int(math.ceil(float(total_num_emails) / float(settings.BULK_EMAIL_EMAILS_PER_QUERY)))
     last_pk = recipient_qset[0].pk - 1
-    num_workers = 0
+    num_emails_queued = 0
+    task_list = []
+    subtask_id_list = []
     for _ in range(num_queries):
-        recipient_sublist = list(recipient_qset.order_by('pk').filter(pk__gt=last_pk)
-                                 .values('profile__name', 'email', 'pk')[:settings.EMAILS_PER_QUERY])
+        recipient_sublist = list(recipient_qset.order_by('pk').filter(pk__gt=last_pk).values('profile__name', 'email', 'pk')[:settings.BULK_EMAIL_EMAILS_PER_QUERY])
         last_pk = recipient_sublist[-1]['pk']
         num_emails_this_query = len(recipient_sublist)
-        num_tasks_this_query = int(math.ceil(float(num_emails_this_query) / float(settings.EMAILS_PER_TASK)))
+        num_tasks_this_query = int(math.ceil(float(num_emails_this_query) / float(settings.BULK_EMAIL_EMAILS_PER_TASK)))
         chunk = int(math.ceil(float(num_emails_this_query) / float(num_tasks_this_query)))
         for i in range(num_tasks_this_query):
             to_list = recipient_sublist[i * chunk:i * chunk + chunk]
-            course_email.delay(
-                email_id,
-                to_list,
-                course.display_name,
-                course_url,
-                image_url,
-                False
-            )
-        num_workers += num_tasks_this_query
-    return num_workers
+            subtask_id = str(uuid4())
+            subtask_id_list.append(subtask_id)
+            new_subtask = create_subtask_fcn(to_list, subtask_id)
+            task_list.append(new_subtask)
+
+        num_emails_queued += num_emails_this_query
+
+    # Sanity check: we expect the chunking to be properly summing to the original count:
+    if num_emails_queued != total_num_emails:
+        error_msg = "Task {}: number of emails generated by chunking {} not equal to original total {}".format(num_emails_queued, total_num_emails)
+        log.error(error_msg)
+        raise ValueError(error_msg)
 
+    return task_list, subtask_id_list, total_num_emails
 
-@task(default_retry_delay=15, max_retries=5)  # pylint: disable=E1102
-def course_email(email_id, to_list, course_title, course_url, image_url, throttle=False):
+
+def perform_delegate_email_batches(entry_id, course_id, task_input, action_name):
     """
-    Takes a primary id for a CourseEmail object and a 'to_list' of recipient objects--keys are
-    'profile__name', 'email' (address), and 'pk' (in the user table).
-    course_title, course_url, and image_url are to memoize course properties and save lookups.
+    Delegates emails by querying for the list of recipients who should
+    get the mail, chopping up into batches of settings.BULK_EMAIL_EMAILS_PER_TASK size,
+    and queueing up worker jobs.
 
-    Sends to all addresses contained in to_list.  Emails are sent multi-part, in both plain
-    text and html.
+    Returns the number of batches (workers) kicked off.
     """
-    with dog_stats_api.timer('course_email.single_task.time.overall', tags=[_statsd_tag(course_title)]):
-        _send_course_email(email_id, to_list, course_title, course_url, image_url, throttle)
+    entry = InstructorTask.objects.get(pk=entry_id)
+    # Get inputs to use in this task from the entry.
+    user_id = entry.requester.id
+    task_id = entry.task_id
+
+    # Perfunctory check, since expansion is made for convenience of other task
+    # code that doesn't need the entry_id.
+    if course_id != entry.course_id:
+        format_msg = "Course id conflict: explicit value {} does not match task value {}"
+        raise ValueError(format_msg.format(course_id, entry.course_id))
+
+    # Fetch the CourseEmail.
+    email_id = task_input['email_id']
+    try:
+        email_obj = CourseEmail.objects.get(id=email_id)
+    except CourseEmail.DoesNotExist:
+        # The CourseEmail object should be committed in the view function before the task
+        # is submitted and reaches this point.
+        log.warning("Task %s: Failed to get CourseEmail with id %s", task_id, email_id)
+        raise
+
+    # Check to see if email batches have already been defined.  This seems to
+    # happen sometimes when there is a loss of connection while a task is being
+    # queued.  When this happens, the same task gets called again, and a whole
+    # new raft of subtasks gets queued up.  We will assume that if subtasks
+    # have already been defined, there is no need to redefine them below.
+    # So we just return right away.  We don't raise an exception, because we want
+    # the current task to be marked with whatever it had been marked with before.
+    if len(entry.subtasks) > 0 and len(entry.task_output) > 0:
+        log.warning("Task %s has already been processed for email %s!  InstructorTask = %s", task_id, email_id, entry)
+        progress = json.loads(entry.task_output)
+        return progress
+
+    # Sanity check that course for email_obj matches that of the task referencing it.
+    if course_id != email_obj.course_id:
+        format_msg = "Course id conflict: explicit value {} does not match email value {}"
+        raise ValueError(format_msg.format(course_id, email_obj.course_id))
+
+    # Fetch the course object.
+    try:
+        course = get_course(course_id)
+    except ValueError:
+        log.exception("Task %s: course not found: %s", task_id, course_id)
+        raise
 
-def _send_course_email(email_id, to_list, course_title, course_url, image_url, throttle):
+    to_option = email_obj.to_option
+    recipient_qset = _get_recipient_queryset(user_id, to_option, course_id, course.location)
+    global_email_context = _get_course_email_context(course)
+
+    def _create_send_email_subtask(to_list, subtask_id):
+        """Creates a subtask to send email to a given recipient list."""
+        subtask_status = create_subtask_status(subtask_id)
+        new_subtask = send_course_email.subtask(
+            (
+                entry_id,
+                email_id,
+                to_list,
+                global_email_context,
+                subtask_status,
+            ),
+            task_id=subtask_id,
+            routing_key=settings.BULK_EMAIL_ROUTING_KEY,
+        )
+        return new_subtask
+
+    log.info("Task %s: Preparing to generate subtasks for course %s, email %s, to_option %s",
+             task_id, course_id, email_id, to_option)
+    task_list, subtask_id_list, total_num_emails = _generate_subtasks(_create_send_email_subtask, recipient_qset)
+
+    # Update the InstructorTask  with information about the subtasks we've defined.
+    log.info("Task %s: Preparing to update task for sending %d emails for course %s, email %s, to_option %s",
+             task_id, total_num_emails, course_id, email_id, to_option)
+    progress = initialize_subtask_info(entry, action_name, total_num_emails, subtask_id_list)
+    num_subtasks = len(subtask_id_list)
+
+    # Now group the subtasks, and start them running.  This allows all the subtasks
+    # in the list to be submitted at the same time.
+    log.info("Task %s: Preparing to queue %d email tasks (%d emails) for course %s, email %s, to %s",
+             task_id, num_subtasks, total_num_emails, course_id, email_id, to_option)
+    task_group = group(task_list)
+    task_group.apply_async(routing_key=settings.BULK_EMAIL_ROUTING_KEY)
+
+    # We want to return progress here, as this is what will be stored in the
+    # AsyncResult for the parent task as its return value.
+    # The AsyncResult will then be marked as SUCCEEDED, and have this return value as its "result".
+    # That's okay, for the InstructorTask will have the "real" status, and monitoring code
+    # should be using that instead.
+    return progress
+
+
+@task(default_retry_delay=settings.BULK_EMAIL_DEFAULT_RETRY_DELAY, max_retries=settings.BULK_EMAIL_MAX_RETRIES)  # pylint: disable=E1102
+def send_course_email(entry_id, email_id, to_list, global_email_context, subtask_status):
     """
-    Performs the email sending task.
+    Sends an email to a list of recipients.
+
+    Inputs are:
+      * `entry_id`: id of the InstructorTask object to which progress should be recorded.
+      * `email_id`: id of the CourseEmail model that is to be emailed.
+      * `to_list`: list of recipients.  Each is represented as a dict with the following keys:
+        - 'profile__name': full name of User.
+        - 'email': email address of User.
+        - 'pk': primary key of User model.
+      * `global_email_context`: dict containing values that are unique for this email but the same
+        for all recipients of this email.  This dict is to be used to fill in slots in email
+        template.  It does not include 'name' and 'email', which will be provided by the to_list.
+      * `subtask_status` : dict containing values representing current status.  Keys are:
+
+        'task_id' : id of subtask.  This is used to pass task information across retries.
+        'attempted' : number of attempts -- should equal succeeded plus failed
+        'succeeded' : number that succeeded in processing
+        'skipped' : number that were not processed.
+        'failed' : number that failed during processing
+        'retried_nomax' : number of times the subtask has been retried for conditions that
+            should not have a maximum count applied
+        'retried_withmax' : number of times the subtask has been retried for conditions that
+            should have a maximum count applied
+        'state' : celery state of the subtask (e.g. QUEUING, PROGRESS, RETRY, FAILURE, SUCCESS)
+
+        Most values will be zero on initial call, but may be different when the task is
+        invoked as part of a retry.
+
+    Sends to all addresses contained in to_list that are not also in the Optout table.
+    Emails are sent multi-part, in both plain text and html.  Updates InstructorTask object
+    with status information (sends, failures, skips) and updates number of subtasks completed.
     """
+    current_task_id = subtask_status['task_id']
+    num_to_send = len(to_list)
+    log.info("Preparing to send email %s to %d recipients as subtask %s for instructor task %d: context = %s, status=%s",
+             email_id, num_to_send, current_task_id, entry_id, global_email_context, subtask_status)
+
+    # Check that the requested subtask is actually known to the current InstructorTask entry.
+    # If this fails, it throws an exception, which should fail this subtask immediately.
+    # This can happen when the parent task has been run twice, and results in duplicate
+    # subtasks being created for the same InstructorTask entry.  We hope to catch this condition
+    # in perform_delegate_email_batches(), but just in case we fail to do so there,
+    # we check here as well.
+    check_subtask_is_valid(entry_id, current_task_id)
+
+    send_exception = None
+    new_subtask_status = None
     try:
-        msg = CourseEmail.objects.get(id=email_id)
-    except CourseEmail.DoesNotExist:
-        log.exception("Could not find email id:{} to send.".format(email_id))
+        course_title = global_email_context['course_title']
+        with dog_stats_api.timer('course_email.single_task.time.overall', tags=[_statsd_tag(course_title)]):
+            new_subtask_status, send_exception = _send_course_email(
+                entry_id,
+                email_id,
+                to_list,
+                global_email_context,
+                subtask_status,
+            )
+    except Exception:
+        # Unexpected exception. Try to write out the failure to the entry before failing.
+        log.exception("Send-email task %s: failed unexpectedly!", current_task_id)
+        # We got here for really unexpected reasons.  Since we don't know how far
+        # the task got in emailing, we count all recipients as having failed.
+        # It at least keeps the counts consistent.
+        new_subtask_status = increment_subtask_status(subtask_status, failed=num_to_send, state=FAILURE)
+        update_subtask_status(entry_id, current_task_id, new_subtask_status)
         raise
 
-    # exclude optouts
-    optouts = (Optout.objects.filter(course_id=msg.course_id,
-                                     user__in=[i['pk'] for i in to_list])
-                             .values_list('user__email', flat=True))
+    if send_exception is None:
+        # Update the InstructorTask object that is storing its progress.
+        log.info("Send-email task %s: succeeded", current_task_id)
+        update_subtask_status(entry_id, current_task_id, new_subtask_status)
+    elif isinstance(send_exception, RetryTaskError):
+        # If retrying, a RetryTaskError needs to be returned to Celery.
+        # We assume that the the progress made before the retry condition
+        # was encountered has already been updated before the retry call was made,
+        # so we only log here.
+        log.warning("Send-email task %s: being retried", current_task_id)
+        raise send_exception  # pylint: disable=E0702
+    else:
+        log.error("Send-email task %s: failed: %s", current_task_id, send_exception)
+        update_subtask_status(entry_id, current_task_id, new_subtask_status)
+        raise send_exception  # pylint: disable=E0702
+
+    log.info("Send-email task %s: returning status %s", current_task_id, new_subtask_status)
+    return new_subtask_status
+
 
+def _filter_optouts_from_recipients(to_list, course_id):
+    """
+    Filters a recipient list based on student opt-outs for a given course.
+
+    Returns the filtered recipient list, as well as the number of optouts
+    removed from the list.
+    """
+    optouts = Optout.objects.filter(
+        course_id=course_id,
+        user__in=[i['pk'] for i in to_list]
+    ).values_list('user__email', flat=True)
     optouts = set(optouts)
+    # Only count the num_optout for the first time the optouts are calculated.
+    # We assume that the number will not change on retries, and so we don't need
+    # to calculate it each time.
     num_optout = len(optouts)
-
     to_list = [recipient for recipient in to_list if recipient['email'] not in optouts]
+    return to_list, num_optout
 
-    subject = "[" + course_title + "] " + msg.subject
 
+def _get_source_address(course_id, course_title):
+    """
+    Calculates an email address to be used as the 'from-address' for sent emails.
+
+    Makes a unique from name and address for each course, e.g.
+
+        "COURSE_TITLE" Course Staff <coursenum-no-reply@courseupdates.edx.org>
+
+    """
     course_title_no_quotes = re.sub(r'"', '', course_title)
-    from_addr = '"{0}" Course Staff <{1}>'.format(course_title_no_quotes, settings.DEFAULT_BULK_FROM_EMAIL)
 
-    course_email_template = CourseEmailTemplate.get_template()
+    # The course_id is assumed to be in the form 'org/course_num/run',
+    # so pull out the course_num.  Then make sure that it can be used
+    # in an email address, by substituting a '_' anywhere a non-(ascii, period, or dash)
+    # character appears.
+    course_num = course_id.split('/')[1]
+    invalid_chars = re.compile(r"[^\w.-]")
+    course_num = invalid_chars.sub('_', course_num)
+
+    from_addr = '"{0}" Course Staff <{1}-{2}>'.format(course_title_no_quotes, course_num, settings.BULK_EMAIL_DEFAULT_FROM_EMAIL)
+    return from_addr
+
+
+def _send_course_email(entry_id, email_id, to_list, global_email_context, subtask_status):
+    """
+    Performs the email sending task.
+
+    Sends an email to a list of recipients.
+
+    Inputs are:
+      * `entry_id`: id of the InstructorTask object to which progress should be recorded.
+      * `email_id`: id of the CourseEmail model that is to be emailed.
+      * `to_list`: list of recipients.  Each is represented as a dict with the following keys:
+        - 'profile__name': full name of User.
+        - 'email': email address of User.
+        - 'pk': primary key of User model.
+      * `global_email_context`: dict containing values that are unique for this email but the same
+        for all recipients of this email.  This dict is to be used to fill in slots in email
+        template.  It does not include 'name' and 'email', which will be provided by the to_list.
+      * `subtask_status` : dict containing values representing current status.  Keys are:
+
+        'task_id' : id of subtask.  This is used to pass task information across retries.
+        'attempted' : number of attempts -- should equal succeeded plus failed
+        'succeeded' : number that succeeded in processing
+        'skipped' : number that were not processed.
+        'failed' : number that failed during processing
+        'retried_nomax' : number of times the subtask has been retried for conditions that
+            should not have a maximum count applied
+        'retried_withmax' : number of times the subtask has been retried for conditions that
+            should have a maximum count applied
+        'state' : celery state of the subtask (e.g. QUEUING, PROGRESS, RETRY, FAILURE, SUCCESS)
+
+    Sends to all addresses contained in to_list that are not also in the Optout table.
+    Emails are sent multi-part, in both plain text and html.
+
+    Returns a tuple of two values:
+      * First value is a dict which represents current progress at the end of this call.  Keys are
+        the same as for the input subtask_status.
+
+      * Second value is an exception returned by the innards of the method, indicating a fatal error.
+        In this case, the number of recipients that were not sent have already been added to the
+        'failed' count above.
+    """
+    # Get information from current task's request:
+    task_id = subtask_status['task_id']
+
+    # collect stats on progress:
+    num_optout = 0
+    num_sent = 0
+    num_error = 0
+
+    try:
+        course_email = CourseEmail.objects.get(id=email_id)
+    except CourseEmail.DoesNotExist as exc:
+        log.exception("Task %s: could not find email id:%s to send.", task_id, email_id)
+        raise
 
+    # Exclude optouts (if not a retry):
+    # Note that we don't have to do the optout logic at all if this is a retry,
+    # because we have presumably already performed the optout logic on the first
+    # attempt.  Anyone on the to_list on a retry has already passed the filter
+    # that existed at that time, and we don't need to keep checking for changes
+    # in the Optout list.
+    if (subtask_status['retried_nomax'] + subtask_status['retried_withmax']) == 0:
+        to_list, num_optout = _filter_optouts_from_recipients(to_list, course_email.course_id)
+
+    course_title = global_email_context['course_title']
+    subject = "[" + course_title + "] " + course_email.subject
+    from_addr = _get_source_address(course_email.course_id, course_title)
+
+    course_email_template = CourseEmailTemplate.get_template()
     try:
         connection = get_connection()
         connection.open()
-        num_sent = 0
-        num_error = 0
 
         # Define context values to use in all course emails:
-        email_context = {
-            'name': '',
-            'email': '',
-            'course_title': course_title,
-            'course_url': course_url,
-            'course_image_url': image_url,
-            'account_settings_url': 'https://{}{}'.format(settings.SITE_NAME, reverse('dashboard')),
-            'platform_name': settings.PLATFORM_NAME,
-        }
+        email_context = {'name': '', 'email': ''}
+        email_context.update(global_email_context)
 
         while to_list:
-            # Update context with user-specific values:
-            email = to_list[-1]['email']
+            # Update context with user-specific values from the user at the end of the list.
+            # At the end of processing this user, they will be popped off of the to_list.
+            # That way, the to_list will always contain the recipients remaining to be emailed.
+            # This is convenient for retries, which will need to send to those who haven't
+            # yet been emailed, but not send to those who have already been sent to.
+            current_recipient = to_list[-1]
+            email = current_recipient['email']
             email_context['email'] = email
-            email_context['name'] = to_list[-1]['profile__name']
+            email_context['name'] = current_recipient['profile__name']
 
             # Construct message content using templates and context:
-            plaintext_msg = course_email_template.render_plaintext(msg.text_message, email_context)
-            html_msg = course_email_template.render_htmltext(msg.html_message, email_context)
+            plaintext_msg = course_email_template.render_plaintext(course_email.text_message, email_context)
+            html_msg = course_email_template.render_htmltext(course_email.html_message, email_context)
 
             # Create email:
             email_msg = EmailMultiAlternatives(
@@ -183,66 +509,247 @@ def _send_course_email(email_id, to_list, course_title, course_url, image_url, t
             )
             email_msg.attach_alternative(html_msg, 'text/html')
 
-            # Throttle if we tried a few times and got the rate limiter
-            if throttle or current_task.request.retries > 0:
-                time.sleep(0.2)
+            # Throttle if we have gotten the rate limiter.  This is not very high-tech,
+            # but if a task has been retried for rate-limiting reasons, then we sleep
+            # for a period of time between all emails within this task.  Choice of
+            # the value depends on the number of workers that might be sending email in
+            # parallel, and what the SES throttle rate is.
+            if subtask_status['retried_nomax'] > 0:
+                sleep(settings.BULK_EMAIL_RETRY_DELAY_BETWEEN_SENDS)
 
             try:
+                log.debug('Email with id %s to be sent to %s', email_id, email)
+
                 with dog_stats_api.timer('course_email.single_send.time.overall', tags=[_statsd_tag(course_title)]):
                     connection.send_messages([email_msg])
 
-                dog_stats_api.increment('course_email.sent', tags=[_statsd_tag(course_title)])
-
-                log.info('Email with id %s sent to %s', email_id, email)
-                num_sent += 1
             except SMTPDataError as exc:
-                # According to SMTP spec, we'll retry error codes in the 4xx range.  5xx range indicates hard failure
+                # According to SMTP spec, we'll retry error codes in the 4xx range.  5xx range indicates hard failure.
                 if exc.smtp_code >= 400 and exc.smtp_code < 500:
-                    # This will cause the outer handler to catch the exception and retry the entire task
+                    # This will cause the outer handler to catch the exception and retry the entire task.
                     raise exc
                 else:
-                    # This will fall through and not retry the message, since it will be popped
-                    log.warning('Email with id %s not delivered to %s due to error %s', email_id, email, exc.smtp_error)
-
+                    # This will fall through and not retry the message.
+                    log.warning('Task %s: email with id %s not delivered to %s due to error %s', task_id, email_id, email, exc.smtp_error)
                     dog_stats_api.increment('course_email.error', tags=[_statsd_tag(course_title)])
-
                     num_error += 1
 
+            except SINGLE_EMAIL_FAILURE_ERRORS as exc:
+                # This will fall through and not retry the message.
+                log.warning('Task %s: email with id %s not delivered to %s due to error %s', task_id, email_id, email, exc)
+                dog_stats_api.increment('course_email.error', tags=[_statsd_tag(course_title)])
+                num_error += 1
+
+            else:
+                dog_stats_api.increment('course_email.sent', tags=[_statsd_tag(course_title)])
+                if settings.BULK_EMAIL_LOG_SENT_EMAILS:
+                    log.info('Email with id %s sent to %s', email_id, email)
+                else:
+                    log.debug('Email with id %s sent to %s', email_id, email)
+                num_sent += 1
+
+            # Pop the user that was emailed off the end of the list only once they have
+            # successfully been processed.  (That way, if there were a failure that
+            # needed to be retried, the user is still on the list.)
             to_list.pop()
 
+    except INFINITE_RETRY_ERRORS as exc:
+        dog_stats_api.increment('course_email.infinite_retry', tags=[_statsd_tag(course_title)])
+        # Increment the "retried_nomax" counter, update other counters with progress to date,
+        # and set the state to RETRY:
+        subtask_progress = increment_subtask_status(
+            subtask_status,
+            succeeded=num_sent,
+            failed=num_error,
+            skipped=num_optout,
+            retried_nomax=1,
+            state=RETRY
+        )
+        return _submit_for_retry(
+            entry_id, email_id, to_list, global_email_context, exc, subtask_progress, skip_retry_max=True
+        )
+
+    except LIMITED_RETRY_ERRORS as exc:
+        # Errors caught here cause the email to be retried.  The entire task is actually retried
+        # without popping the current recipient off of the existing list.
+        # Errors caught are those that indicate a temporary condition that might succeed on retry.
+        dog_stats_api.increment('course_email.limited_retry', tags=[_statsd_tag(course_title)])
+        # Increment the "retried_withmax" counter, update other counters with progress to date,
+        # and set the state to RETRY:
+        subtask_progress = increment_subtask_status(
+            subtask_status,
+            succeeded=num_sent,
+            failed=num_error,
+            skipped=num_optout,
+            retried_withmax=1,
+            state=RETRY
+        )
+        return _submit_for_retry(
+            entry_id, email_id, to_list, global_email_context, exc, subtask_progress, skip_retry_max=False
+        )
+
+    except BULK_EMAIL_FAILURE_ERRORS as exc:
+        dog_stats_api.increment('course_email.error', tags=[_statsd_tag(course_title)])
+        num_pending = len(to_list)
+        log.exception('Task %s: email with id %d caused send_course_email task to fail with "fatal" exception.  %d emails unsent.',
+                      task_id, email_id, num_pending)
+        # Update counters with progress to date, counting unsent emails as failures,
+        # and set the state to FAILURE:
+        subtask_progress = increment_subtask_status(
+            subtask_status,
+            succeeded=num_sent,
+            failed=(num_error + num_pending),
+            skipped=num_optout,
+            state=FAILURE
+        )
+        return subtask_progress, exc
+
+    except Exception as exc:
+        # Errors caught here cause the email to be retried.  The entire task is actually retried
+        # without popping the current recipient off of the existing list.
+        # These are unexpected errors.  Since they might be due to a temporary condition that might
+        # succeed on retry, we give them a retry.
+        dog_stats_api.increment('course_email.limited_retry', tags=[_statsd_tag(course_title)])
+        log.exception('Task %s: email with id %d caused send_course_email task to fail with unexpected exception.  Generating retry.',
+                      task_id, email_id)
+        # Increment the "retried_withmax" counter, update other counters with progress to date,
+        # and set the state to RETRY:
+        subtask_progress = increment_subtask_status(
+            subtask_status,
+            succeeded=num_sent,
+            failed=num_error,
+            skipped=num_optout,
+            retried_withmax=1,
+            state=RETRY
+        )
+        return _submit_for_retry(
+            entry_id, email_id, to_list, global_email_context, exc, subtask_progress, skip_retry_max=False
+        )
+
+    else:
+        # All went well.  Update counters with progress to date,
+        # and set the state to SUCCESS:
+        subtask_progress = increment_subtask_status(
+            subtask_status,
+            succeeded=num_sent,
+            failed=num_error,
+            skipped=num_optout,
+            state=SUCCESS
+        )
+        # Successful completion is marked by an exception value of None.
+        return subtask_progress, None
+    finally:
+        # Clean up at the end.
         connection.close()
-        return course_email_result(num_sent, num_error, num_optout)
-
-    except (SMTPDataError, SMTPConnectError, SMTPServerDisconnected) as exc:
-        # Error caught here cause the email to be retried.  The entire task is actually retried without popping the list
-        # Reasoning is that all of these errors may be temporary condition.
-        log.warning('Email with id %d not delivered due to temporary error %s, retrying send to %d recipients',
-                    email_id, exc, len(to_list))
-        raise course_email.retry(
-            arg=[
+
+
+def _get_current_task():
+    """
+    Stub to make it easier to test without actually running Celery.
+
+    This is a wrapper around celery.current_task, which provides access
+    to the top of the stack of Celery's tasks.  When running tests, however,
+    it doesn't seem to work to mock current_task directly, so this wrapper
+    is used to provide a hook to mock in tests, while providing the real
+    `current_task` in production.
+    """
+    return current_task
+
+
+def _submit_for_retry(entry_id, email_id, to_list, global_email_context, current_exception, subtask_status, skip_retry_max=False):
+    """
+    Helper function to requeue a task for retry, using the new version of arguments provided.
+
+    Inputs are the same as for running a task, plus two extra indicating the state at the time of retry.
+    These include the `current_exception` that the task encountered that is causing the retry attempt,
+    and the `subtask_status` that is to be returned.  A third extra argument `skip_retry_max`
+    indicates whether the current retry should be subject to a maximum test.
+
+    Returns a tuple of two values:
+      * First value is a dict which represents current progress.  Keys are:
+
+        'task_id' : id of subtask.  This is used to pass task information across retries.
+        'attempted' : number of attempts -- should equal succeeded plus failed
+        'succeeded' : number that succeeded in processing
+        'skipped' : number that were not processed.
+        'failed' : number that failed during processing
+        'retried_nomax' : number of times the subtask has been retried for conditions that
+            should not have a maximum count applied
+        'retried_withmax' : number of times the subtask has been retried for conditions that
+            should have a maximum count applied
+        'state' : celery state of the subtask (e.g. QUEUING, PROGRESS, RETRY, FAILURE, SUCCESS)
+
+      * Second value is an exception returned by the innards of the method.  If the retry was
+        successfully submitted, this value will be the RetryTaskError that retry() returns.
+        Otherwise, it (ought to be) the current_exception passed in.
+    """
+    task_id = subtask_status['task_id']
+    log.info("Task %s: Successfully sent to %s users; failed to send to %s users (and skipped %s users)",
+             task_id, subtask_status['succeeded'], subtask_status['failed'], subtask_status['skipped'])
+
+    # Calculate time until we retry this task (in seconds):
+    # The value for max_retries is increased by the number of times an "infinite-retry" exception
+    # has been retried.  We want the regular retries to trigger max-retry checking, but not these
+    # special retries.  So we count them separately.
+    max_retries = _get_current_task().max_retries + subtask_status['retried_nomax']
+    base_delay = _get_current_task().default_retry_delay
+    if skip_retry_max:
+        # once we reach five retries, don't increase the countdown further.
+        retry_index = min(subtask_status['retried_nomax'], 5)
+        exception_type = 'sending-rate'
+        # if we have a cap, after all, apply it now:
+        if hasattr(settings, 'BULK_EMAIL_INFINITE_RETRY_CAP'):
+            retry_cap = settings.BULK_EMAIL_INFINITE_RETRY_CAP + subtask_status['retried_withmax']
+            max_retries = min(max_retries, retry_cap)
+    else:
+        retry_index = subtask_status['retried_withmax']
+        exception_type = 'transient'
+
+    # Skew the new countdown value by a random factor, so that not all
+    # retries are deferred by the same amount.
+    countdown = ((2 ** retry_index) * base_delay) * random.uniform(.75, 1.25)
+
+    log.warning('Task %s: email with id %d not delivered due to %s error %s, retrying send to %d recipients in %s seconds (with max_retry=%s)',
+                task_id, email_id, exception_type, current_exception, len(to_list), countdown, max_retries)
+
+    # we make sure that we update the InstructorTask with the current subtask status
+    # *before* actually calling retry(), to be sure that there is no race
+    # condition between this update and the update made by the retried task.
+    update_subtask_status(entry_id, task_id, subtask_status)
+
+    # Now attempt the retry.  If it succeeds, it returns a RetryTaskError that
+    # needs to be returned back to Celery.  If it fails, we return the existing
+    # exception.
+    try:
+        send_course_email.retry(
+            args=[
+                entry_id,
                 email_id,
                 to_list,
-                course_title,
-                course_url,
-                image_url,
-                current_task.request.retries > 0
+                global_email_context,
+                subtask_status,
             ],
-            exc=exc,
-            countdown=(2 ** current_task.request.retries) * 15
+            exc=current_exception,
+            countdown=countdown,
+            max_retries=max_retries,
+            throw=True,
         )
-    except:
-        log.exception('Email with id %d caused course_email task to fail with uncaught exception. To list: %s',
-                      email_id,
-                      [i['email'] for i in to_list])
-        # Close the connection before we exit
-        connection.close()
-        raise
-
-
-# This string format code is wrapped in this function to allow mocking for a unit test
-def course_email_result(num_sent, num_error, num_optout):
-    """Return the formatted result of course_email sending."""
-    return "Sent {0}, Fail {1}, Optout {2}".format(num_sent, num_error, num_optout)
+    except RetryTaskError as retry_error:
+        # If the retry call is successful, update with the current progress:
+        log.exception('Task %s: email with id %d caused send_course_email task to retry.',
+                      task_id, email_id)
+        return subtask_status, retry_error
+    except Exception as retry_exc:
+        # If there are no more retries, because the maximum has been reached,
+        # we expect the original exception to be raised.  We catch it here
+        # (and put it in retry_exc just in case it's different, but it shouldn't be),
+        # and update status as if it were any other failure.  That means that
+        # the recipients still in the to_list are counted as failures.
+        log.exception('Task %s: email with id %d caused send_course_email task to fail to retry. To list: %s',
+                      task_id, email_id, [i['email'] for i in to_list])
+        num_failed = len(to_list)
+        new_subtask_progress = increment_subtask_status(subtask_status, failed=num_failed, state=FAILURE)
+        return new_subtask_progress, retry_exc
 
 
 def _statsd_tag(course_title):
diff --git a/lms/djangoapps/bulk_email/tests/test_course_optout.py b/lms/djangoapps/bulk_email/tests/test_course_optout.py
index 0adf11952701..378610eeb369 100644
--- a/lms/djangoapps/bulk_email/tests/test_course_optout.py
+++ b/lms/djangoapps/bulk_email/tests/test_course_optout.py
@@ -59,7 +59,7 @@ def navigate_to_email_view(self):
         selected_email_link = '<a href="#" onclick="goto(\'Email\')" class="selectedmode">Email</a>'
         self.assertTrue(selected_email_link in response.content)
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True})
+    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': False})
     def test_optout_course(self):
         """
         Make sure student does not receive course email after opting out.
@@ -88,7 +88,7 @@ def test_optout_course(self):
         # Assert that self.student.email not in mail.to, outbox should be empty
         self.assertEqual(len(mail.outbox), 0)
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True})
+    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': False})
     def test_optin_course(self):
         """
         Make sure student receives course email after opting in.
diff --git a/lms/djangoapps/bulk_email/tests/test_email.py b/lms/djangoapps/bulk_email/tests/test_email.py
index dab7812763b4..9da787dbaa31 100644
--- a/lms/djangoapps/bulk_email/tests/test_email.py
+++ b/lms/djangoapps/bulk_email/tests/test_email.py
@@ -2,6 +2,8 @@
 """
 Unit tests for sending course email
 """
+from mock import patch
+
 from django.conf import settings
 from django.core import mail
 from django.core.urlresolvers import reverse
@@ -12,11 +14,8 @@
 from student.tests.factories import UserFactory, GroupFactory, CourseEnrollmentFactory
 from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory
-
-from bulk_email.tasks import delegate_email_batches, course_email
-from bulk_email.models import CourseEmail, Optout
-
-from mock import patch
+from bulk_email.models import Optout
+from instructor_task.subtasks import increment_subtask_status
 
 STAFF_COUNT = 3
 STUDENT_COUNT = 10
@@ -30,13 +29,13 @@ class MockCourseEmailResult(object):
     """
     emails_sent = 0
 
-    def get_mock_course_email_result(self):
+    def get_mock_increment_subtask_status(self):
         """Wrapper for mock email function."""
-        def mock_course_email_result(sent, failed, output, **kwargs):  # pylint: disable=W0613
+        def mock_increment_subtask_status(original_status, **kwargs):  # pylint: disable=W0613
             """Increments count of number of emails sent."""
-            self.emails_sent += sent
-            return True
-        return mock_course_email_result
+            self.emails_sent += kwargs.get('succeeded', 0)
+            return increment_subtask_status(original_status, **kwargs)
+        return mock_increment_subtask_status
 
 
 @override_settings(MODULESTORE=TEST_DATA_MONGO_MODULESTORE)
@@ -45,7 +44,7 @@ class TestEmailSendFromDashboard(ModuleStoreTestCase):
     Test that emails send correctly.
     """
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True})
+    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': False})
     def setUp(self):
         self.course = CourseFactory.create()
         self.instructor = UserFactory.create(username="instructor", email="robot+instructor@edx.org")
@@ -244,14 +243,14 @@ def test_unicode_students_send_to_all(self):
             [self.instructor.email] + [s.email for s in self.staff] + [s.email for s in self.students]
         )
 
-    @override_settings(EMAILS_PER_TASK=3, EMAILS_PER_QUERY=7)
-    @patch('bulk_email.tasks.course_email_result')
+    @override_settings(BULK_EMAIL_EMAILS_PER_TASK=3, BULK_EMAIL_EMAILS_PER_QUERY=7)
+    @patch('bulk_email.tasks.increment_subtask_status')
     def test_chunked_queries_send_numerous_emails(self, email_mock):
         """
         Test sending a large number of emails, to test the chunked querying
         """
         mock_factory = MockCourseEmailResult()
-        email_mock.side_effect = mock_factory.get_mock_course_email_result()
+        email_mock.side_effect = mock_factory.get_mock_increment_subtask_status()
         added_users = []
         for _ in xrange(LARGE_NUM_EMAILS):
             user = UserFactory()
@@ -281,14 +280,3 @@ def test_chunked_queries_send_numerous_emails(self, email_mock):
                                 [s.email for s in self.students] +
                                 [s.email for s in added_users if s not in optouts])
         self.assertItemsEqual(outbox_contents, should_send_contents)
-
-
-@override_settings(MODULESTORE=TEST_DATA_MONGO_MODULESTORE)
-class TestEmailSendExceptions(ModuleStoreTestCase):
-    """
-    Test that exceptions are handled correctly.
-    """
-    def test_no_course_email_obj(self):
-        # Make sure course_email handles CourseEmail.DoesNotExist exception.
-        with self.assertRaises(CourseEmail.DoesNotExist):
-            course_email(101, [], "_", "_", "_", False)
diff --git a/lms/djangoapps/bulk_email/tests/test_err_handling.py b/lms/djangoapps/bulk_email/tests/test_err_handling.py
index abdbf4dc3b13..a7ec72c56ed8 100644
--- a/lms/djangoapps/bulk_email/tests/test_err_handling.py
+++ b/lms/djangoapps/bulk_email/tests/test_err_handling.py
@@ -2,21 +2,24 @@
 Unit tests for handling email sending errors
 """
 from itertools import cycle
+from mock import patch
+from smtplib import SMTPDataError, SMTPServerDisconnected, SMTPConnectError
+
 from django.test.utils import override_settings
 from django.conf import settings
 from django.core.management import call_command
 from django.core.urlresolvers import reverse
 
+
 from courseware.tests.tests import TEST_DATA_MONGO_MODULESTORE
 from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
 from xmodule.modulestore.tests.factories import CourseFactory
 from student.tests.factories import UserFactory, AdminFactory, CourseEnrollmentFactory
 
-from bulk_email.models import CourseEmail
-from bulk_email.tasks import delegate_email_batches
-
-from mock import patch, Mock
-from smtplib import SMTPDataError, SMTPServerDisconnected, SMTPConnectError
+from bulk_email.models import CourseEmail, SEND_TO_ALL
+from bulk_email.tasks import perform_delegate_email_batches, send_course_email
+from instructor_task.models import InstructorTask
+from instructor_task.subtasks import create_subtask_status, initialize_subtask_info
 
 
 class EmailTestException(Exception):
@@ -43,7 +46,7 @@ def tearDown(self):
         patch.stopall()
 
     @patch('bulk_email.tasks.get_connection', autospec=True)
-    @patch('bulk_email.tasks.course_email.retry')
+    @patch('bulk_email.tasks.send_course_email.retry')
     def test_data_err_retry(self, retry, get_conn):
         """
         Test that celery handles transient SMTPDataErrors by retrying.
@@ -64,15 +67,16 @@ def test_data_err_retry(self, retry, get_conn):
         self.assertTrue(type(exc) == SMTPDataError)
 
     @patch('bulk_email.tasks.get_connection', autospec=True)
-    @patch('bulk_email.tasks.course_email_result')
-    @patch('bulk_email.tasks.course_email.retry')
+    @patch('bulk_email.tasks.increment_subtask_status')
+    @patch('bulk_email.tasks.send_course_email.retry')
     def test_data_err_fail(self, retry, result, get_conn):
         """
         Test that celery handles permanent SMTPDataErrors by failing and not retrying.
         """
+        # have every fourth email fail due to blacklisting:
         get_conn.return_value.send_messages.side_effect = cycle([SMTPDataError(554, "Email address is blacklisted"),
-                                                                 None])
-        students = [UserFactory() for _ in xrange(settings.EMAILS_PER_TASK)]
+                                                                 None, None, None])
+        students = [UserFactory() for _ in xrange(settings.BULK_EMAIL_EMAILS_PER_TASK)]
         for student in students:
             CourseEnrollmentFactory.create(user=student, course_id=self.course.id)
 
@@ -87,13 +91,14 @@ def test_data_err_fail(self, retry, result, get_conn):
         # We shouldn't retry when hitting a 5xx error
         self.assertFalse(retry.called)
         # Test that after the rejected email, the rest still successfully send
-        ((sent, fail, optouts), _) = result.call_args
-        self.assertEquals(optouts, 0)
-        self.assertEquals(fail, settings.EMAILS_PER_TASK / 2)
-        self.assertEquals(sent, settings.EMAILS_PER_TASK / 2)
+        ((_initial_results), kwargs) = result.call_args
+        self.assertEquals(kwargs['skipped'], 0)
+        expected_fails = int((settings.BULK_EMAIL_EMAILS_PER_TASK + 3) / 4.0)
+        self.assertEquals(kwargs['failed'], expected_fails)
+        self.assertEquals(kwargs['succeeded'], settings.BULK_EMAIL_EMAILS_PER_TASK - expected_fails)
 
     @patch('bulk_email.tasks.get_connection', autospec=True)
-    @patch('bulk_email.tasks.course_email.retry')
+    @patch('bulk_email.tasks.send_course_email.retry')
     def test_disconn_err_retry(self, retry, get_conn):
         """
         Test that celery handles SMTPServerDisconnected by retrying.
@@ -113,7 +118,7 @@ def test_disconn_err_retry(self, retry, get_conn):
         self.assertTrue(type(exc) == SMTPServerDisconnected)
 
     @patch('bulk_email.tasks.get_connection', autospec=True)
-    @patch('bulk_email.tasks.course_email.retry')
+    @patch('bulk_email.tasks.send_course_email.retry')
     def test_conn_err_retry(self, retry, get_conn):
         """
         Test that celery handles SMTPConnectError by retrying.
@@ -133,67 +138,107 @@ def test_conn_err_retry(self, retry, get_conn):
         exc = kwargs['exc']
         self.assertTrue(type(exc) == SMTPConnectError)
 
-    @patch('bulk_email.tasks.course_email_result')
-    @patch('bulk_email.tasks.course_email.retry')
+    @patch('bulk_email.tasks.increment_subtask_status')
     @patch('bulk_email.tasks.log')
-    @patch('bulk_email.tasks.get_connection', Mock(return_value=EmailTestException))
-    def test_general_exception(self, mock_log, retry, result):
-        """
-        Tests the if the error is not SMTP-related, we log and reraise
-        """
-        test_email = {
-            'action': 'Send email',
-            'to_option': 'myself',
-            'subject': 'test subject for myself',
-            'message': 'test message for myself'
-        }
-        # For some reason (probably the weirdness of testing with celery tasks) assertRaises doesn't work here
-        # so we assert on the arguments of log.exception
-        self.client.post(self.url, test_email)
-        ((log_str, email_id, to_list), _) = mock_log.exception.call_args
-        self.assertTrue(mock_log.exception.called)
-        self.assertIn('caused course_email task to fail with uncaught exception.', log_str)
-        self.assertEqual(email_id, 1)
-        self.assertEqual(to_list, [self.instructor.email])
-        self.assertFalse(retry.called)
-        self.assertFalse(result.called)
-
-    @patch('bulk_email.tasks.course_email_result')
-    @patch('bulk_email.tasks.delegate_email_batches.retry')
-    @patch('bulk_email.tasks.log')
-    def test_nonexist_email(self, mock_log, retry, result):
+    def test_nonexistent_email(self, mock_log, result):
         """
         Tests retries when the email doesn't exist
         """
-        delegate_email_batches.delay(-1, self.instructor.id)
-        ((log_str, email_id, _num_retries), _) = mock_log.warning.call_args
+        # create an InstructorTask object to pass through
+        course_id = self.course.id
+        entry = InstructorTask.create(course_id, "task_type", "task_key", "task_input", self.instructor)
+        task_input = {"email_id": -1}
+        with self.assertRaises(CourseEmail.DoesNotExist):
+            perform_delegate_email_batches(entry.id, course_id, task_input, "action_name")  # pylint: disable=E1101
+        ((log_str, _, email_id), _) = mock_log.warning.call_args
         self.assertTrue(mock_log.warning.called)
         self.assertIn('Failed to get CourseEmail with id', log_str)
         self.assertEqual(email_id, -1)
-        self.assertTrue(retry.called)
         self.assertFalse(result.called)
 
-    @patch('bulk_email.tasks.log')
-    def test_nonexist_course(self, mock_log):
+    def test_nonexistent_course(self):
         """
         Tests exception when the course in the email doesn't exist
         """
-        email = CourseEmail(course_id="I/DONT/EXIST")
+        course_id = "I/DONT/EXIST"
+        email = CourseEmail(course_id=course_id)
         email.save()
-        delegate_email_batches.delay(email.id, self.instructor.id)
-        ((log_str, _), _) = mock_log.exception.call_args
-        self.assertTrue(mock_log.exception.called)
-        self.assertIn('get_course_by_id failed:', log_str)
+        entry = InstructorTask.create(course_id, "task_type", "task_key", "task_input", self.instructor)
+        task_input = {"email_id": email.id}  # pylint: disable=E1101
+        with self.assertRaisesRegexp(ValueError, "Course not found"):
+            perform_delegate_email_batches(entry.id, course_id, task_input, "action_name")  # pylint: disable=E1101
 
-    @patch('bulk_email.tasks.log')
-    def test_nonexist_to_option(self, mock_log):
+    def test_nonexistent_to_option(self):
         """
         Tests exception when the to_option in the email doesn't exist
         """
         email = CourseEmail(course_id=self.course.id, to_option="IDONTEXIST")
         email.save()
-        delegate_email_batches.delay(email.id, self.instructor.id)
-        ((log_str, opt_str), _) = mock_log.error.call_args
-        self.assertTrue(mock_log.error.called)
-        self.assertIn('Unexpected bulk email TO_OPTION found', log_str)
-        self.assertEqual("IDONTEXIST", opt_str)
+        entry = InstructorTask.create(self.course.id, "task_type", "task_key", "task_input", self.instructor)
+        task_input = {"email_id": email.id}  # pylint: disable=E1101
+        with self.assertRaisesRegexp(Exception, 'Unexpected bulk email TO_OPTION found: IDONTEXIST'):
+            perform_delegate_email_batches(entry.id, self.course.id, task_input, "action_name")  # pylint: disable=E1101
+
+    def test_wrong_course_id_in_task(self):
+        """
+        Tests exception when the course_id in task is not the same as one explicitly passed in.
+        """
+        email = CourseEmail(course_id=self.course.id, to_option=SEND_TO_ALL)
+        email.save()
+        entry = InstructorTask.create("bogus_task_id", "task_type", "task_key", "task_input", self.instructor)
+        task_input = {"email_id": email.id}  # pylint: disable=E1101
+        with self.assertRaisesRegexp(ValueError, 'does not match task value'):
+            perform_delegate_email_batches(entry.id, self.course.id, task_input, "action_name")  # pylint: disable=E1101
+
+    def test_wrong_course_id_in_email(self):
+        """
+        Tests exception when the course_id in CourseEmail is not the same as one explicitly passed in.
+        """
+        email = CourseEmail(course_id="bogus_course_id", to_option=SEND_TO_ALL)
+        email.save()
+        entry = InstructorTask.create(self.course.id, "task_type", "task_key", "task_input", self.instructor)
+        task_input = {"email_id": email.id}  # pylint: disable=E1101
+        with self.assertRaisesRegexp(ValueError, 'does not match email value'):
+            perform_delegate_email_batches(entry.id, self.course.id, task_input, "action_name")  # pylint: disable=E1101
+
+    def test_send_email_undefined_subtask(self):
+        # test at a lower level, to ensure that the course gets checked down below too.
+        entry = InstructorTask.create(self.course.id, "task_type", "task_key", "task_input", self.instructor)
+        entry_id = entry.id  # pylint: disable=E1101
+        to_list = ['test@test.com']
+        global_email_context = {'course_title': 'dummy course'}
+        subtask_id = "subtask-id-value"
+        subtask_status = create_subtask_status(subtask_id)
+        email_id = 1001
+        with self.assertRaisesRegexp(ValueError, 'unable to find email subtasks of instructor task'):
+            send_course_email(entry_id, email_id, to_list, global_email_context, subtask_status)
+
+    def test_send_email_missing_subtask(self):
+        # test at a lower level, to ensure that the course gets checked down below too.
+        entry = InstructorTask.create(self.course.id, "task_type", "task_key", "task_input", self.instructor)
+        entry_id = entry.id  # pylint: disable=E1101
+        to_list = ['test@test.com']
+        global_email_context = {'course_title': 'dummy course'}
+        subtask_id = "subtask-id-value"
+        initialize_subtask_info(entry, "emailed", 100, [subtask_id])
+        different_subtask_id = "bogus-subtask-id-value"
+        subtask_status = create_subtask_status(different_subtask_id)
+        bogus_email_id = 1001
+        with self.assertRaisesRegexp(ValueError, 'unable to find status for email subtask of instructor task'):
+            send_course_email(entry_id, bogus_email_id, to_list, global_email_context, subtask_status)
+
+    def dont_test_send_email_undefined_email(self):
+        # test at a lower level, to ensure that the course gets checked down below too.
+        entry = InstructorTask.create(self.course.id, "task_type", "task_key", "task_input", self.instructor)
+        entry_id = entry.id  # pylint: disable=E1101
+        to_list = ['test@test.com']
+        global_email_context = {'course_title': 'dummy course'}
+        subtask_id = "subtask-id-value"
+        initialize_subtask_info(entry, "emailed", 100, [subtask_id])
+        subtask_status = create_subtask_status(subtask_id)
+        bogus_email_id = 1001
+        with self.assertRaises(CourseEmail.DoesNotExist):
+            # we skip the call that updates subtask status, since we've not set up the InstructorTask
+            # for the subtask, and it's not important to the test.
+            with patch('bulk_email.tasks.update_subtask_status'):
+                send_course_email(entry_id, bogus_email_id, to_list, global_email_context, subtask_status)
diff --git a/lms/djangoapps/bulk_email/tests/test_forms.py b/lms/djangoapps/bulk_email/tests/test_forms.py
new file mode 100644
index 000000000000..60a8abf95e1c
--- /dev/null
+++ b/lms/djangoapps/bulk_email/tests/test_forms.py
@@ -0,0 +1,105 @@
+"""
+Unit tests for bulk-email-related forms.
+"""
+from django.test.utils import override_settings
+from django.conf import settings
+
+from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
+from xmodule.modulestore.tests.factories import CourseFactory
+from courseware.tests.tests import TEST_DATA_MONGO_MODULESTORE
+from courseware.tests.modulestore_config import TEST_DATA_MIXED_MODULESTORE
+
+from xmodule.modulestore.django import modulestore
+from xmodule.modulestore import MONGO_MODULESTORE_TYPE
+
+from mock import patch
+
+from bulk_email.models import CourseAuthorization
+from bulk_email.forms import CourseAuthorizationAdminForm
+
+
+@override_settings(MODULESTORE=TEST_DATA_MONGO_MODULESTORE)
+class CourseAuthorizationFormTest(ModuleStoreTestCase):
+    """Test the CourseAuthorizationAdminForm form for Mongo-backed courses."""
+
+    def setUp(self):
+        # Make a mongo course
+        self.course = CourseFactory.create()
+
+    def tearDown(self):
+        """
+        Undo all patches.
+        """
+        patch.stopall()
+
+    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
+    def test_authorize_mongo_course(self):
+        # Initially course shouldn't be authorized
+        self.assertFalse(CourseAuthorization.instructor_email_enabled(self.course.id))
+        # Test authorizing the course, which should totally work
+        form_data = {'course_id': self.course.id, 'email_enabled': True}
+        form = CourseAuthorizationAdminForm(data=form_data)
+        # Validation should work
+        self.assertTrue(form.is_valid())
+        form.save()
+        # Check that this course is authorized
+        self.assertTrue(CourseAuthorization.instructor_email_enabled(self.course.id))
+
+    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
+    def test_form_typo(self):
+        # Munge course id
+        bad_id = self.course.id + '_typo'
+
+        form_data = {'course_id': bad_id, 'email_enabled': True}
+        form = CourseAuthorizationAdminForm(data=form_data)
+        # Validation shouldn't work
+        self.assertFalse(form.is_valid())
+
+        msg = u'Error encountered (Course not found.)'
+        msg += ' --- Entered course id was: "{0}". '.format(bad_id)
+        msg += 'Please recheck that you have supplied a course id in the format: ORG/COURSE/RUN'
+        self.assertEquals(msg, form._errors['course_id'][0])  # pylint: disable=protected-access
+
+        with self.assertRaisesRegexp(ValueError, "The CourseAuthorization could not be created because the data didn't validate."):
+            form.save()
+
+    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
+    def test_course_name_only(self):
+        # Munge course id - common
+        bad_id = self.course.id.split('/')[-1]
+
+        form_data = {'course_id': bad_id, 'email_enabled': True}
+        form = CourseAuthorizationAdminForm(data=form_data)
+        # Validation shouldn't work
+        self.assertFalse(form.is_valid())
+
+        msg = u'Error encountered (Need more than 1 value to unpack)'
+        msg += ' --- Entered course id was: "{0}". '.format(bad_id)
+        msg += 'Please recheck that you have supplied a course id in the format: ORG/COURSE/RUN'
+        self.assertEquals(msg, form._errors['course_id'][0])  # pylint: disable=protected-access
+
+        with self.assertRaisesRegexp(ValueError, "The CourseAuthorization could not be created because the data didn't validate."):
+            form.save()
+
+
+@override_settings(MODULESTORE=TEST_DATA_MIXED_MODULESTORE)
+class CourseAuthorizationXMLFormTest(ModuleStoreTestCase):
+    """Check that XML courses cannot be authorized for email."""
+
+    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
+    def test_xml_course_authorization(self):
+        course_id = 'edX/toy/2012_Fall'
+        # Assert this is an XML course
+        self.assertTrue(modulestore().get_modulestore_type(course_id) != MONGO_MODULESTORE_TYPE)
+
+        form_data = {'course_id': course_id, 'email_enabled': True}
+        form = CourseAuthorizationAdminForm(data=form_data)
+        # Validation shouldn't work
+        self.assertFalse(form.is_valid())
+
+        msg = u"Course Email feature is only available for courses authored in Studio. "
+        msg += '"{0}" appears to be an XML backed course.'.format(course_id)
+        self.assertEquals(msg, form._errors['course_id'][0])  # pylint: disable=protected-access
+
+        with self.assertRaisesRegexp(ValueError, "The CourseAuthorization could not be created because the data didn't validate."):
+            form.save()
diff --git a/lms/djangoapps/bulk_email/tests/test_models.py b/lms/djangoapps/bulk_email/tests/test_models.py
new file mode 100644
index 000000000000..30713e178c57
--- /dev/null
+++ b/lms/djangoapps/bulk_email/tests/test_models.py
@@ -0,0 +1,147 @@
+"""
+Unit tests for bulk-email-related models.
+"""
+from django.test import TestCase
+from django.core.management import call_command
+from django.conf import settings
+
+from student.tests.factories import UserFactory
+
+from mock import patch
+
+from bulk_email.models import CourseEmail, SEND_TO_STAFF, CourseEmailTemplate, CourseAuthorization
+
+
+class CourseEmailTest(TestCase):
+    """Test the CourseEmail model."""
+
+    def test_creation(self):
+        course_id = 'abc/123/doremi'
+        sender = UserFactory.create()
+        to_option = SEND_TO_STAFF
+        subject = "dummy subject"
+        html_message = "<html>dummy message</html>"
+        email = CourseEmail.create(course_id, sender, to_option, subject, html_message)
+        self.assertEquals(email.course_id, course_id)
+        self.assertEquals(email.to_option, SEND_TO_STAFF)
+        self.assertEquals(email.subject, subject)
+        self.assertEquals(email.html_message, html_message)
+        self.assertEquals(email.sender, sender)
+
+    def test_bad_to_option(self):
+        course_id = 'abc/123/doremi'
+        sender = UserFactory.create()
+        to_option = "fake"
+        subject = "dummy subject"
+        html_message = "<html>dummy message</html>"
+        with self.assertRaises(ValueError):
+            CourseEmail.create(course_id, sender, to_option, subject, html_message)
+
+
+class NoCourseEmailTemplateTest(TestCase):
+    """Test the CourseEmailTemplate model without loading the template data."""
+
+    def test_get_missing_template(self):
+        with self.assertRaises(CourseEmailTemplate.DoesNotExist):
+            CourseEmailTemplate.get_template()
+
+
+class CourseEmailTemplateTest(TestCase):
+    """Test the CourseEmailTemplate model."""
+
+    def setUp(self):
+        # load initial content (since we don't run migrations as part of tests):
+        call_command("loaddata", "course_email_template.json")
+
+    def _get_sample_plain_context(self):
+        """Provide sample context sufficient for rendering plaintext template"""
+        context = {
+            'course_title': "Bogus Course Title",
+            'course_url': "/location/of/course/url",
+            'account_settings_url': "/location/of/account/settings/url",
+            'platform_name': 'edX',
+            'email': 'your-email@test.com',
+        }
+        return context
+
+    def _get_sample_html_context(self):
+        """Provide sample context sufficient for rendering HTML template"""
+        context = self._get_sample_plain_context()
+        context['course_image_url'] = "/location/of/course/image/url"
+        return context
+
+    def test_get_template(self):
+        template = CourseEmailTemplate.get_template()
+        self.assertIsNotNone(template.html_template)
+        self.assertIsNotNone(template.plain_template)
+
+    def test_render_html_without_context(self):
+        template = CourseEmailTemplate.get_template()
+        base_context = self._get_sample_html_context()
+        for keyname in base_context:
+            context = dict(base_context)
+            del context[keyname]
+            with self.assertRaises(KeyError):
+                template.render_htmltext("My new html text.", context)
+
+    def test_render_plaintext_without_context(self):
+        template = CourseEmailTemplate.get_template()
+        base_context = self._get_sample_plain_context()
+        for keyname in base_context:
+            context = dict(base_context)
+            del context[keyname]
+            with self.assertRaises(KeyError):
+                template.render_plaintext("My new plain text.", context)
+
+    def test_render_html(self):
+        template = CourseEmailTemplate.get_template()
+        context = self._get_sample_html_context()
+        template.render_htmltext("My new html text.", context)
+
+    def test_render_plain(self):
+        template = CourseEmailTemplate.get_template()
+        context = self._get_sample_plain_context()
+        template.render_plaintext("My new plain text.", context)
+
+
+class CourseAuthorizationTest(TestCase):
+    """Test the CourseAuthorization model."""
+
+    @patch.dict(settings.MITX_FEATURES, {'REQUIRE_COURSE_EMAIL_AUTH': True})
+    def test_creation_auth_on(self):
+        course_id = 'abc/123/doremi'
+        # Test that course is not authorized by default
+        self.assertFalse(CourseAuthorization.instructor_email_enabled(course_id))
+
+        # Authorize
+        cauth = CourseAuthorization(course_id=course_id, email_enabled=True)
+        cauth.save()
+        # Now, course should be authorized
+        self.assertTrue(CourseAuthorization.instructor_email_enabled(course_id))
+        self.assertEquals(
+            cauth.__unicode__(),
+            "Course 'abc/123/doremi': Instructor Email Enabled"
+        )
+
+        # Unauthorize by explicitly setting email_enabled to False
+        cauth.email_enabled = False
+        cauth.save()
+        # Test that course is now unauthorized
+        self.assertFalse(CourseAuthorization.instructor_email_enabled(course_id))
+        self.assertEquals(
+            cauth.__unicode__(),
+            "Course 'abc/123/doremi': Instructor Email Not Enabled"
+        )
+
+    @patch.dict(settings.MITX_FEATURES, {'REQUIRE_COURSE_EMAIL_AUTH': False})
+    def test_creation_auth_off(self):
+        course_id = 'blahx/blah101/ehhhhhhh'
+        # Test that course is authorized by default, since auth is turned off
+        self.assertTrue(CourseAuthorization.instructor_email_enabled(course_id))
+
+        # Use the admin interface to unauthorize the course
+        cauth = CourseAuthorization(course_id=course_id, email_enabled=False)
+        cauth.save()
+
+        # Now, course should STILL be authorized!
+        self.assertTrue(CourseAuthorization.instructor_email_enabled(course_id))
diff --git a/lms/djangoapps/bulk_email/tests/test_tasks.py b/lms/djangoapps/bulk_email/tests/test_tasks.py
new file mode 100644
index 000000000000..e49a04147a3d
--- /dev/null
+++ b/lms/djangoapps/bulk_email/tests/test_tasks.py
@@ -0,0 +1,398 @@
+"""
+Unit tests for LMS instructor-initiated background tasks.
+
+Runs tasks on answers to course problems to validate that code
+paths actually work.
+
+"""
+import json
+from uuid import uuid4
+from itertools import cycle, chain, repeat
+from mock import patch, Mock
+from smtplib import SMTPServerDisconnected, SMTPDataError, SMTPConnectError, SMTPAuthenticationError
+from boto.ses.exceptions import (
+    SESDailyQuotaExceededError,
+    SESMaxSendingRateExceededError,
+    SESAddressBlacklistedError,
+    SESIllegalAddressError,
+    SESLocalAddressCharacterError,
+)
+from boto.exception import AWSConnectionError
+
+from celery.states import SUCCESS, FAILURE
+
+from django.conf import settings
+from django.core.management import call_command
+
+from bulk_email.models import CourseEmail, Optout, SEND_TO_ALL
+
+from instructor_task.tasks import send_bulk_course_email
+from instructor_task.subtasks import update_subtask_status
+from instructor_task.models import InstructorTask
+from instructor_task.tests.test_base import InstructorTaskCourseTestCase
+from instructor_task.tests.factories import InstructorTaskFactory
+
+
+class TestTaskFailure(Exception):
+    """Dummy exception used for unit tests."""
+    pass
+
+
+def my_update_subtask_status(entry_id, current_task_id, new_subtask_status):
+    """
+    Check whether a subtask has been updated before really updating.
+
+    Check whether a subtask which has been retried
+    has had the retry already write its results here before the code
+    that was invoking the retry had a chance to update this status.
+
+    This is the norm in "eager" mode (used by tests) where the retry is called
+    and run to completion before control is returned to the code that
+    invoked the retry.  If the retries eventually end in failure (e.g. due to
+    a maximum number of retries being attempted), the "eager" code will return
+    the error for each retry as it is popped off the stack.  We want to just ignore
+    the later updates that are called as the result of the earlier retries.
+
+    This should not be an issue in production, where status is updated before
+    a task is retried, and is then updated afterwards if the retry fails.
+    """
+    entry = InstructorTask.objects.get(pk=entry_id)
+    subtask_dict = json.loads(entry.subtasks)
+    subtask_status_info = subtask_dict['status']
+    current_subtask_status = subtask_status_info[current_task_id]
+
+    def _get_retry_count(subtask_result):
+        """Return the number of retries counted for the given subtask."""
+        retry_count = subtask_result.get('retried_nomax', 0)
+        retry_count += subtask_result.get('retried_withmax', 0)
+        return retry_count
+
+    current_retry_count = _get_retry_count(current_subtask_status)
+    new_retry_count = _get_retry_count(new_subtask_status)
+    if current_retry_count <= new_retry_count:
+        update_subtask_status(entry_id, current_task_id, new_subtask_status)
+
+
+class TestBulkEmailInstructorTask(InstructorTaskCourseTestCase):
+    """Tests instructor task that send bulk email."""
+
+    def setUp(self):
+        super(TestBulkEmailInstructorTask, self).setUp()
+        self.initialize_course()
+        self.instructor = self.create_instructor('instructor')
+
+        # load initial content (since we don't run migrations as part of tests):
+        call_command("loaddata", "course_email_template.json")
+
+    def _create_input_entry(self, course_id=None):
+        """
+        Creates a InstructorTask entry for testing.
+
+        Overrides the base class version in that this creates CourseEmail.
+        """
+        to_option = SEND_TO_ALL
+        course_id = course_id or self.course.id
+        course_email = CourseEmail.create(course_id, self.instructor, to_option, "Test Subject", "<p>This is a test message</p>")
+        task_input = {'email_id': course_email.id}  # pylint: disable=E1101
+        task_id = str(uuid4())
+        instructor_task = InstructorTaskFactory.create(
+            course_id=course_id,
+            requester=self.instructor,
+            task_input=json.dumps(task_input),
+            task_key='dummy value',
+            task_id=task_id,
+        )
+        return instructor_task
+
+    def _run_task_with_mock_celery(self, task_class, entry_id, task_id):
+        """Submit a task and mock how celery provides a current_task."""
+        mock_current_task = Mock()
+        mock_current_task.max_retries = settings.BULK_EMAIL_MAX_RETRIES
+        mock_current_task.default_retry_delay = settings.BULK_EMAIL_DEFAULT_RETRY_DELAY
+        task_args = [entry_id, {}]
+
+        with patch('bulk_email.tasks._get_current_task') as mock_get_task:
+            mock_get_task.return_value = mock_current_task
+            return task_class.apply(task_args, task_id=task_id).get()
+
+    def test_email_missing_current_task(self):
+        task_entry = self._create_input_entry()
+        with self.assertRaises(ValueError):
+            send_bulk_course_email(task_entry.id, {})
+
+    def test_email_undefined_course(self):
+        # Check that we fail when passing in a course that doesn't exist.
+        task_entry = self._create_input_entry(course_id="bogus/course/id")
+        with self.assertRaises(ValueError):
+            self._run_task_with_mock_celery(send_bulk_course_email, task_entry.id, task_entry.task_id)
+
+    def test_bad_task_id_on_update(self):
+        task_entry = self._create_input_entry()
+
+        def dummy_update_subtask_status(entry_id, _current_task_id, new_subtask_status):
+            """Passes a bad value for task_id to test update_subtask_status"""
+            bogus_task_id = "this-is-bogus"
+            update_subtask_status(entry_id, bogus_task_id, new_subtask_status)
+
+        with self.assertRaises(ValueError):
+            with patch('bulk_email.tasks.update_subtask_status', dummy_update_subtask_status):
+                send_bulk_course_email(task_entry.id, {})  # pylint: disable=E1101
+
+    def _create_students(self, num_students):
+        """Create students for testing"""
+        return [self.create_student('robot%d' % i) for i in xrange(num_students)]
+
+    def _assert_single_subtask_status(self, entry, succeeded, failed=0, skipped=0, retried_nomax=0, retried_withmax=0):
+        """Compare counts with 'subtasks' entry in InstructorTask table."""
+        subtask_info = json.loads(entry.subtasks)
+        # verify subtask-level counts:
+        self.assertEquals(subtask_info.get('total'), 1)
+        self.assertEquals(subtask_info.get('succeeded'), 1 if succeeded > 0 else 0)
+        self.assertEquals(subtask_info.get('failed'), 0 if succeeded > 0 else 1)
+        # verify individual subtask status:
+        subtask_status_info = subtask_info.get('status')
+        task_id_list = subtask_status_info.keys()
+        self.assertEquals(len(task_id_list), 1)
+        task_id = task_id_list[0]
+        subtask_status = subtask_status_info.get(task_id)
+        print("Testing subtask status: {}".format(subtask_status))
+        self.assertEquals(subtask_status.get('task_id'), task_id)
+        self.assertEquals(subtask_status.get('attempted'), succeeded + failed)
+        self.assertEquals(subtask_status.get('succeeded'), succeeded)
+        self.assertEquals(subtask_status.get('skipped'), skipped)
+        self.assertEquals(subtask_status.get('failed'), failed)
+        self.assertEquals(subtask_status.get('retried_nomax'), retried_nomax)
+        self.assertEquals(subtask_status.get('retried_withmax'), retried_withmax)
+        self.assertEquals(subtask_status.get('state'), SUCCESS if succeeded > 0 else FAILURE)
+
+    def _test_run_with_task(self, task_class, action_name, total, succeeded, failed=0, skipped=0, retried_nomax=0, retried_withmax=0):
+        """Run a task and check the number of emails processed."""
+        task_entry = self._create_input_entry()
+        parent_status = self._run_task_with_mock_celery(task_class, task_entry.id, task_entry.task_id)
+
+        # check return value
+        self.assertEquals(parent_status.get('total'), total)
+        self.assertEquals(parent_status.get('action_name'), action_name)
+
+        # compare with task_output entry in InstructorTask table:
+        entry = InstructorTask.objects.get(id=task_entry.id)
+        status = json.loads(entry.task_output)
+        self.assertEquals(status.get('attempted'), succeeded + failed)
+        self.assertEquals(status.get('succeeded'), succeeded)
+        self.assertEquals(status.get('skipped'), skipped)
+        self.assertEquals(status.get('failed'), failed)
+        self.assertEquals(status.get('total'), total)
+        self.assertEquals(status.get('action_name'), action_name)
+        self.assertGreater(status.get('duration_ms'), 0)
+        self.assertEquals(entry.task_state, SUCCESS)
+        self._assert_single_subtask_status(entry, succeeded, failed, skipped, retried_nomax, retried_withmax)
+        return entry
+
+    def test_successful(self):
+        # Select number of emails to fit into a single subtask.
+        num_emails = settings.BULK_EMAIL_EMAILS_PER_TASK
+        # We also send email to the instructor:
+        self._create_students(num_emails - 1)
+        with patch('bulk_email.tasks.get_connection', autospec=True) as get_conn:
+            get_conn.return_value.send_messages.side_effect = cycle([None])
+            self._test_run_with_task(send_bulk_course_email, 'emailed', num_emails, num_emails)
+
+    def test_successful_twice(self):
+        # Select number of emails to fit into a single subtask.
+        num_emails = settings.BULK_EMAIL_EMAILS_PER_TASK
+        # We also send email to the instructor:
+        self._create_students(num_emails - 1)
+        with patch('bulk_email.tasks.get_connection', autospec=True) as get_conn:
+            get_conn.return_value.send_messages.side_effect = cycle([None])
+            task_entry = self._test_run_with_task(send_bulk_course_email, 'emailed', num_emails, num_emails)
+
+        # submit the same task a second time, and confirm that it is not run again.
+        with patch('bulk_email.tasks.get_connection', autospec=True) as get_conn:
+            get_conn.return_value.send_messages.side_effect = cycle([Exception("This should not happen!")])
+            parent_status = self._run_task_with_mock_celery(send_bulk_course_email, task_entry.id, task_entry.task_id)
+        self.assertEquals(parent_status.get('total'), num_emails)
+        self.assertEquals(parent_status.get('succeeded'), num_emails)
+        self.assertEquals(parent_status.get('failed'), 0)
+
+    def test_unactivated_user(self):
+        # Select number of emails to fit into a single subtask.
+        num_emails = settings.BULK_EMAIL_EMAILS_PER_TASK
+        # We also send email to the instructor:
+        students = self._create_students(num_emails - 1)
+        # mark a student as not yet having activated their email:
+        student = students[0]
+        student.is_active = False
+        student.save()
+        with patch('bulk_email.tasks.get_connection', autospec=True) as get_conn:
+            get_conn.return_value.send_messages.side_effect = cycle([None])
+            self._test_run_with_task(send_bulk_course_email, 'emailed', num_emails - 1, num_emails - 1)
+
+    def test_skipped(self):
+        # Select number of emails to fit into a single subtask.
+        num_emails = settings.BULK_EMAIL_EMAILS_PER_TASK
+        # We also send email to the instructor:
+        students = self._create_students(num_emails - 1)
+        # have every fourth student optout:
+        expected_skipped = int((num_emails + 3) / 4.0)
+        expected_succeeds = num_emails - expected_skipped
+        for index in range(0, num_emails, 4):
+            Optout.objects.create(user=students[index], course_id=self.course.id)
+        # mark some students as opting out
+        with patch('bulk_email.tasks.get_connection', autospec=True) as get_conn:
+            get_conn.return_value.send_messages.side_effect = cycle([None])
+            self._test_run_with_task(send_bulk_course_email, 'emailed', num_emails, expected_succeeds, skipped=expected_skipped)
+
+    def _test_email_address_failures(self, exception):
+        """Test that celery handles bad address errors by failing and not retrying."""
+        # Select number of emails to fit into a single subtask.
+        num_emails = settings.BULK_EMAIL_EMAILS_PER_TASK
+        # We also send email to the instructor:
+        self._create_students(num_emails - 1)
+        expected_fails = int((num_emails + 3) / 4.0)
+        expected_succeeds = num_emails - expected_fails
+        with patch('bulk_email.tasks.get_connection', autospec=True) as get_conn:
+            # have every fourth email fail due to some address failure:
+            get_conn.return_value.send_messages.side_effect = cycle([exception, None, None, None])
+            self._test_run_with_task(send_bulk_course_email, 'emailed', num_emails, expected_succeeds, failed=expected_fails)
+
+    def test_smtp_blacklisted_user(self):
+        # Test that celery handles permanent SMTPDataErrors by failing and not retrying.
+        self._test_email_address_failures(SMTPDataError(554, "Email address is blacklisted"))
+
+    def test_ses_blacklisted_user(self):
+        # Test that celery handles permanent SMTPDataErrors by failing and not retrying.
+        self._test_email_address_failures(SESAddressBlacklistedError(554, "Email address is blacklisted"))
+
+    def test_ses_illegal_address(self):
+        # Test that celery handles permanent SMTPDataErrors by failing and not retrying.
+        self._test_email_address_failures(SESIllegalAddressError(554, "Email address is illegal"))
+
+    def test_ses_local_address_character_error(self):
+        # Test that celery handles permanent SMTPDataErrors by failing and not retrying.
+        self._test_email_address_failures(SESLocalAddressCharacterError(554, "Email address contains a bad character"))
+
+    def _test_retry_after_limited_retry_error(self, exception):
+        """Test that celery handles connection failures by retrying."""
+        # If we want the batch to succeed, we need to send fewer emails
+        # than the max retries, so that the max is not triggered.
+        num_emails = settings.BULK_EMAIL_MAX_RETRIES
+        # We also send email to the instructor:
+        self._create_students(num_emails - 1)
+        expected_fails = 0
+        expected_succeeds = num_emails
+        with patch('bulk_email.tasks.get_connection', autospec=True) as get_conn:
+            # Have every other mail attempt fail due to disconnection.
+            get_conn.return_value.send_messages.side_effect = cycle([exception, None])
+            self._test_run_with_task(
+                send_bulk_course_email,
+                'emailed',
+                num_emails,
+                expected_succeeds,
+                failed=expected_fails,
+                retried_withmax=num_emails
+            )
+
+    def _test_max_retry_limit_causes_failure(self, exception):
+        """Test that celery can hit a maximum number of retries."""
+        # Doesn't really matter how many recipients, since we expect
+        # to fail on the first.
+        num_emails = 10
+        # We also send email to the instructor:
+        self._create_students(num_emails - 1)
+        expected_fails = num_emails
+        expected_succeeds = 0
+        with patch('bulk_email.tasks.get_connection', autospec=True) as get_conn:
+            # always fail to connect, triggering repeated retries until limit is hit:
+            get_conn.return_value.send_messages.side_effect = cycle([exception])
+            with patch('bulk_email.tasks.update_subtask_status', my_update_subtask_status):
+                self._test_run_with_task(
+                    send_bulk_course_email,
+                    'emailed',
+                    num_emails,
+                    expected_succeeds,
+                    failed=expected_fails,
+                    retried_withmax=(settings.BULK_EMAIL_MAX_RETRIES + 1)
+                )
+
+    def test_retry_after_smtp_disconnect(self):
+        self._test_retry_after_limited_retry_error(SMTPServerDisconnected(425, "Disconnecting"))
+
+    def test_max_retry_after_smtp_disconnect(self):
+        self._test_max_retry_limit_causes_failure(SMTPServerDisconnected(425, "Disconnecting"))
+
+    def test_retry_after_smtp_connect_error(self):
+        self._test_retry_after_limited_retry_error(SMTPConnectError(424, "Bad Connection"))
+
+    def test_max_retry_after_smtp_connect_error(self):
+        self._test_max_retry_limit_causes_failure(SMTPConnectError(424, "Bad Connection"))
+
+    def test_retry_after_aws_connect_error(self):
+        self._test_retry_after_limited_retry_error(AWSConnectionError("Unable to provide secure connection through proxy"))
+
+    def test_max_retry_after_aws_connect_error(self):
+        self._test_max_retry_limit_causes_failure(AWSConnectionError("Unable to provide secure connection through proxy"))
+
+    def test_retry_after_general_error(self):
+        self._test_retry_after_limited_retry_error(Exception("This is some random exception."))
+
+    def test_max_retry_after_general_error(self):
+        self._test_max_retry_limit_causes_failure(Exception("This is some random exception."))
+
+    def _test_retry_after_unlimited_retry_error(self, exception):
+        """Test that celery handles throttling failures by retrying."""
+        num_emails = 8
+        # We also send email to the instructor:
+        self._create_students(num_emails - 1)
+        expected_fails = 0
+        expected_succeeds = num_emails
+        # Note that because celery in eager mode will call retries synchronously,
+        # each retry will increase the stack depth.  It turns out that there is a
+        # maximum depth at which a RuntimeError is raised ("maximum recursion depth
+        # exceeded").  The maximum recursion depth is 90, so
+        # num_emails * expected_retries < 90.
+        expected_retries = 10
+        with patch('bulk_email.tasks.get_connection', autospec=True) as get_conn:
+            # Cycle through N throttling errors followed by a success.
+            get_conn.return_value.send_messages.side_effect = cycle(
+                chain(repeat(exception, expected_retries), [None])
+            )
+            self._test_run_with_task(
+                send_bulk_course_email,
+                'emailed',
+                num_emails,
+                expected_succeeds,
+                failed=expected_fails,
+                retried_nomax=(expected_retries * num_emails)
+            )
+
+    def test_retry_after_smtp_throttling_error(self):
+        self._test_retry_after_unlimited_retry_error(SMTPDataError(455, "Throttling: Sending rate exceeded"))
+
+    def test_retry_after_ses_throttling_error(self):
+        self._test_retry_after_unlimited_retry_error(SESMaxSendingRateExceededError(455, "Throttling: Sending rate exceeded"))
+
+    def _test_immediate_failure(self, exception):
+        """Test that celery can hit a maximum number of retries."""
+        # Doesn't really matter how many recipients, since we expect
+        # to fail on the first.
+        num_emails = 10
+        # We also send email to the instructor:
+        self._create_students(num_emails - 1)
+        expected_fails = num_emails
+        expected_succeeds = 0
+        with patch('bulk_email.tasks.get_connection', autospec=True) as get_conn:
+            # always fail to connect, triggering repeated retries until limit is hit:
+            get_conn.return_value.send_messages.side_effect = cycle([exception])
+            self._test_run_with_task(
+                send_bulk_course_email,
+                'emailed',
+                num_emails,
+                expected_succeeds,
+                failed=expected_fails,
+            )
+
+    def test_failure_on_unhandled_smtp(self):
+        self._test_immediate_failure(SMTPAuthenticationError(403, "That password doesn't work!"))
+
+    def test_failure_on_ses_quota_exceeded(self):
+        self._test_immediate_failure(SESDailyQuotaExceededError(403, "You're done for the day!"))
diff --git a/lms/djangoapps/courseware/courses.py b/lms/djangoapps/courseware/courses.py
index 78e1d51cbc31..106373139cf0 100644
--- a/lms/djangoapps/courseware/courses.py
+++ b/lms/djangoapps/courseware/courses.py
@@ -36,11 +36,31 @@ def get_request_for_thread():
         del frame
 
 
+def get_course(course_id, depth=0):
+    """
+    Given a course id, return the corresponding course descriptor.
+
+    If course_id is not valid, raises a ValueError.  This is appropriate
+    for internal use.
+
+    depth: The number of levels of children for the modulestore to cache.
+    None means infinite depth.  Default is to fetch no children.
+    """
+    try:
+        course_loc = CourseDescriptor.id_to_location(course_id)
+        return modulestore().get_instance(course_id, course_loc, depth=depth)
+    except (KeyError, ItemNotFoundError):
+        raise ValueError("Course not found: {}".format(course_id))
+    except InvalidLocationError:
+        raise ValueError("Invalid location: {}".format(course_id))
+
+
 def get_course_by_id(course_id, depth=0):
     """
     Given a course id, return the corresponding course descriptor.
 
     If course_id is not valid, raises a 404.
+
     depth: The number of levels of children for the modulestore to cache. None means infinite depth
     """
     try:
@@ -51,6 +71,7 @@ def get_course_by_id(course_id, depth=0):
     except InvalidLocationError:
         raise Http404("Invalid location")
 
+
 def get_course_with_access(user, course_id, action, depth=0):
     """
     Given a course_id, look up the corresponding course descriptor,
@@ -182,7 +203,6 @@ def get_course_about_section(course, section_key):
     raise KeyError("Invalid about key " + str(section_key))
 
 
-
 def get_course_info_section(request, course, section_key):
     """
     This returns the snippet of html to be rendered on the course info page,
@@ -194,8 +214,6 @@ def get_course_info_section(request, course, section_key):
     - updates
     - guest_updates
     """
-
-
     loc = Location(course.location.tag, course.location.org, course.location.course, 'course_info', section_key)
 
     # Use an empty cache
diff --git a/lms/djangoapps/courseware/features/video.feature b/lms/djangoapps/courseware/features/video.feature
index 001481a6a5c1..7518bf6bdb96 100644
--- a/lms/djangoapps/courseware/features/video.feature
+++ b/lms/djangoapps/courseware/features/video.feature
@@ -2,38 +2,45 @@
 Feature: LMS.Video component
   As a student, I want to view course videos in LMS.
 
+  # 1
   Scenario: Video component is fully rendered in the LMS in HTML5 mode
     Given the course has a Video component in HTML5 mode
     Then when I view the video it has rendered in HTML5 mode
     And all sources are correct
 
+  # 2
   # Firefox doesn't have HTML5 (only mp4 - fix here)
   @skip_firefox
   Scenario: Autoplay is disabled in LMS for a Video component
     Given the course has a Video component in HTML5 mode
     Then when I view the video it does not have autoplay enabled
 
+  # 3
   # Youtube testing
   Scenario: Video component is fully rendered in the LMS in Youtube mode with HTML5 sources
     Given youtube server is up and response time is  0.4 seconds
     And the course has a Video component in Youtube_HTML5 mode
     Then when I view the video it has rendered in Youtube mode
 
+  # 4
   Scenario: Video component is not rendered in the LMS in Youtube mode with HTML5 sources
     Given youtube server is up and response time is 2 seconds
     And the course has a Video component in Youtube_HTML5 mode
     Then when I view the video it has rendered in HTML5 mode
 
+  # 5
   Scenario: Video component is rendered in the LMS in Youtube mode without HTML5 sources
     Given youtube server is up and response time is 2 seconds
     And the course has a Video component in Youtube mode
     Then when I view the video it has rendered in Youtube mode
 
+  # 6
   Scenario: Video component is rendered in the LMS in Youtube mode with HTML5 sources that doesn't supported by browser
     Given youtube server is up and response time is 2 seconds
     And the course has a Video component in Youtube_HTML5_Unsupported_Video mode
     Then when I view the video it has rendered in Youtube mode
 
+  # 7
   Scenario: Video component is rendered in the LMS in HTML5 mode with HTML5 sources that doesn't supported by browser
     Given the course has a Video component in HTML5_Unsupported_Video mode
     Then error message is shown
diff --git a/lms/djangoapps/courseware/tests/test_courses.py b/lms/djangoapps/courseware/tests/test_courses.py
index 20cb83a411b9..7960515ae0bd 100644
--- a/lms/djangoapps/courseware/tests/test_courses.py
+++ b/lms/djangoapps/courseware/tests/test_courses.py
@@ -2,15 +2,18 @@
 from django.test import TestCase
 from django.http import Http404
 from django.test.utils import override_settings
-from courseware.courses import get_course_by_id, get_cms_course_link_by_id
+from courseware.courses import get_course_by_id, get_course, get_cms_course_link_by_id
 
 CMS_BASE_TEST = 'testcms'
 
+
 class CoursesTest(TestCase):
+    """Test methods related to fetching courses."""
+
     def test_get_course_by_id_invalid_chars(self):
         """
         Test that `get_course_by_id` throws a 404, rather than
-        an exception, when faced with unexpected characters 
+        an exception, when faced with unexpected characters
         (such as unicode characters, and symbols such as = and ' ')
         """
         with self.assertRaises(Http404):
@@ -18,6 +21,17 @@ def test_get_course_by_id_invalid_chars(self):
             get_course_by_id('MITx/foobar/business and management')
             get_course_by_id('MITx/foobar/NiñøJoséMaríáßç')
 
+    def test_get_course_invalid_chars(self):
+        """
+        Test that `get_course` throws a ValueError, rather than
+        a 404, when faced with unexpected characters
+        (such as unicode characters, and symbols such as = and ' ')
+        """
+        with self.assertRaises(ValueError):
+            get_course('MITx/foobar/statistics=introduction')
+            get_course('MITx/foobar/business and management')
+            get_course('MITx/foobar/NiñøJoséMaríáßç')
+
     @override_settings(CMS_BASE=CMS_BASE_TEST)
     def test_get_cms_course_link_by_id(self):
         """
diff --git a/lms/djangoapps/instructor/features/bulk_email.feature b/lms/djangoapps/instructor/features/bulk_email.feature
new file mode 100644
index 000000000000..8d3784c1ea36
--- /dev/null
+++ b/lms/djangoapps/instructor/features/bulk_email.feature
@@ -0,0 +1,20 @@
+@shard_2
+Feature: Bulk Email
+    As an instructor or course staff,
+    In order to communicate with students and staff
+    I want to send email to staff and students in a course.
+
+    Scenario: Send bulk email
+    Given I am "<Role>" for a course
+    When I send email to "<Recipient>"
+    Then Email is sent to "<Recipient>"
+
+    Examples:
+    | Role          |  Recipient     |
+    | instructor    |  myself        |
+    | instructor    |  course staff  |
+    | instructor    |  students, staff, and instructors  |
+    | staff         |  myself        |
+    | staff         |  course staff  |
+    | staff         |  students, staff, and instructors  |
+    
diff --git a/lms/djangoapps/instructor/features/bulk_email.py b/lms/djangoapps/instructor/features/bulk_email.py
new file mode 100644
index 000000000000..220ab9ecee55
--- /dev/null
+++ b/lms/djangoapps/instructor/features/bulk_email.py
@@ -0,0 +1,162 @@
+"""
+Define steps for bulk email acceptance test.
+"""
+
+#pylint: disable=C0111
+#pylint: disable=W0621
+
+from lettuce import world, step
+from lettuce.django import mail
+from nose.tools import assert_in, assert_true, assert_equal  # pylint: disable=E0611
+from django.core.management import call_command
+from django.conf import settings
+
+
+@step(u'I am an instructor for a course')
+def i_am_an_instructor(step):  # pylint: disable=W0613
+
+    # Clear existing courses to avoid conflicts
+    world.clear_courses()
+
+    # Register the instructor as staff for the course
+    world.register_by_course_id(
+        'edx/999/Test_Course',
+        username='instructor',
+        password='password',
+        is_staff=True
+    )
+    world.add_to_course_staff('instructor', '999')
+
+    # Register another staff member
+    world.register_by_course_id(
+        'edx/999/Test_Course',
+        username='staff',
+        password='password',
+        is_staff=True
+    )
+    world.add_to_course_staff('staff', '999')
+
+    # Register a student
+    world.register_by_course_id(
+        'edx/999/Test_Course',
+        username='student',
+        password='password',
+        is_staff=False
+    )
+
+    # Log in as the instructor for the course
+    world.log_in(
+        username='instructor',
+        password='password',
+        email="instructor@edx.org",
+        name="Instructor"
+    )
+
+
+# Dictionary mapping a description of the email recipient
+# to the corresponding <option> value in the UI.
+SEND_TO_OPTIONS = {
+    'myself': 'myself',
+    'course staff': 'staff',
+    'students, staff, and instructors': 'all'
+}
+
+
+@step(u'I send email to "([^"]*)"')
+def when_i_send_an_email(recipient):
+
+    # Check that the recipient is valid
+    assert_in(
+        recipient, SEND_TO_OPTIONS,
+        msg="Invalid recipient: {}".format(recipient)
+    )
+
+    # Because we flush the database before each run,
+    # we need to ensure that the email template fixture
+    # is re-loaded into the database
+    call_command('loaddata', 'course_email_template.json')
+
+    # Go to the email section of the instructor dash
+    world.visit('/courses/edx/999/Test_Course')
+    world.css_click('a[href="/courses/edx/999/Test_Course/instructor"]')
+    world.css_click('div.beta-button-wrapper>a')
+    world.css_click('a[data-section="send_email"]')
+
+    # Select the recipient
+    world.select_option('send_to', SEND_TO_OPTIONS[recipient])
+
+    # Enter subject and message
+    world.css_fill('input#id_subject', 'Hello')
+
+    with world.browser.get_iframe('mce_0_ifr') as iframe:
+        editor = iframe.find_by_id('tinymce')[0]
+        editor.fill('test message')
+
+    # Click send
+    world.css_click('input[name="send"]')
+
+    # Expect to see a message that the email was sent
+    expected_msg = "Your email was successfully queued for sending."
+    assert_true(
+        world.css_has_text('div.request-response', expected_msg, '#request-response', allow_blank=False),
+        msg="Could not find email success message."
+    )
+
+
+# Dictionaries mapping description of email recipient
+# to the expected recipient email addresses
+EXPECTED_ADDRESSES = {
+    'myself': ['instructor@edx.org'],
+    'course staff': ['instructor@edx.org', 'staff@edx.org'],
+    'students, staff, and instructors': ['instructor@edx.org', 'staff@edx.org', 'student@edx.org']
+}
+
+UNSUBSCRIBE_MSG = 'To stop receiving email like this'
+
+
+@step(u'Email is sent to "([^"]*)"')
+def then_the_email_is_sent(recipient):
+
+    # Check that the recipient is valid
+    assert_in(
+        recipient, SEND_TO_OPTIONS,
+        msg="Invalid recipient: {}".format(recipient)
+    )
+
+    # Retrieve messages.  Because we are using celery in "always eager"
+    # mode, we expect all messages to be sent by this point.
+    messages = []
+    while not mail.queue.empty():  # pylint: disable=E1101
+        messages.append(mail.queue.get())  # pylint: disable=E1101
+
+    # Check that we got the right number of messages
+    assert_equal(
+        len(messages), len(EXPECTED_ADDRESSES[recipient]),
+        msg="Received {0} instead of {1} messages for {2}".format(
+            len(messages), len(EXPECTED_ADDRESSES[recipient]), recipient
+        )
+    )
+
+    # Check that the message properties were correct
+    recipients = []
+    for msg in messages:
+        assert_in('Hello', msg.subject)
+        assert_in(settings.DEFAULT_BULK_FROM_EMAIL, msg.from_email)
+
+        # Message body should have the message we sent
+        # and an unsubscribe message
+        assert_in('test message', msg.body)
+        assert_in(UNSUBSCRIBE_MSG, msg.body)
+
+        # Should have alternative HTML form
+        assert_equal(len(msg.alternatives), 1)
+        content = msg.alternatives[0]
+        assert_in('test message', content)
+        assert_in(UNSUBSCRIBE_MSG, content)
+
+        # Store the recipient address so we can verify later
+        recipients.extend(msg.recipients())
+
+    # Check that the messages were sent to the right people
+    for addr in EXPECTED_ADDRESSES[recipient]:
+        assert_in(addr, recipients)
diff --git a/lms/djangoapps/instructor/tests/test_api.py b/lms/djangoapps/instructor/tests/test_api.py
index a32217ab30b7..693e832e5d3b 100644
--- a/lms/djangoapps/instructor/tests/test_api.py
+++ b/lms/djangoapps/instructor/tests/test_api.py
@@ -6,7 +6,6 @@
 import json
 import requests
 from urllib import quote
-from django.conf import settings
 from django.test import TestCase
 from nose.tools import raises
 from mock import Mock, patch
@@ -125,6 +124,7 @@ def test_staff_level(self):
             'list_forum_members',
             'update_forum_role_membership',
             'proxy_legacy_analytics',
+            'send_email',
         ]
         for endpoint in staff_level_endpoints:
             url = reverse(endpoint, kwargs={'course_id': self.course.id})
@@ -280,8 +280,8 @@ class TestInstructorAPILevelsAccess(ModuleStoreTestCase, LoginEnrollmentTestCase
     This test does NOT test whether the actions had an effect on the
     database, that is the job of test_access.
     This tests the response and action switch.
-    Actually, modify_access does not having a very meaningful
-        response yet, so only the status code is tested.
+    Actually, modify_access does not have a very meaningful
+    response yet, so only the status code is tested.
     """
     def setUp(self):
         self.instructor = AdminFactory.create()
@@ -691,7 +691,74 @@ def test_rescore_problem_all(self, act):
         })
         print response.content
         self.assertEqual(response.status_code, 200)
-        self.assertTrue(act.called)
+
+
+@override_settings(MODULESTORE=TEST_DATA_MIXED_MODULESTORE)
+class TestInstructorSendEmail(ModuleStoreTestCase, LoginEnrollmentTestCase):
+    """
+    Checks that only instructors have access to email endpoints, and that
+    these endpoints are only accessible with courses that actually exist,
+    only with valid email messages.
+    """
+    def setUp(self):
+        self.instructor = AdminFactory.create()
+        self.course = CourseFactory.create()
+        self.client.login(username=self.instructor.username, password='test')
+        test_subject = u'\u1234 test subject'
+        test_message = u'\u6824 test message'
+        self.full_test_message = {
+            'send_to': 'staff',
+            'subject': test_subject,
+            'message': test_message,
+        }
+
+    def test_send_email_as_logged_in_instructor(self):
+        url = reverse('send_email', kwargs={'course_id': self.course.id})
+        response = self.client.post(url, self.full_test_message)
+        self.assertEqual(response.status_code, 200)
+
+    def test_send_email_but_not_logged_in(self):
+        self.client.logout()
+        url = reverse('send_email', kwargs={'course_id': self.course.id})
+        response = self.client.post(url, self.full_test_message)
+        self.assertEqual(response.status_code, 403)
+
+    def test_send_email_but_not_staff(self):
+        self.client.logout()
+        student = UserFactory()
+        self.client.login(username=student.username, password='test')
+        url = reverse('send_email', kwargs={'course_id': self.course.id})
+        response = self.client.post(url, self.full_test_message)
+        self.assertEqual(response.status_code, 403)
+
+    def test_send_email_but_course_not_exist(self):
+        url = reverse('send_email', kwargs={'course_id': 'GarbageCourse/DNE/NoTerm'})
+        response = self.client.post(url, self.full_test_message)
+        self.assertNotEqual(response.status_code, 200)
+
+    def test_send_email_no_sendto(self):
+        url = reverse('send_email', kwargs={'course_id': self.course.id})
+        response = self.client.post(url, {
+            'subject': 'test subject',
+            'message': 'test message',
+        })
+        self.assertEqual(response.status_code, 400)
+
+    def test_send_email_no_subject(self):
+        url = reverse('send_email', kwargs={'course_id': self.course.id})
+        response = self.client.post(url, {
+            'send_to': 'staff',
+            'message': 'test message',
+        })
+        self.assertEqual(response.status_code, 400)
+
+    def test_send_email_no_message(self):
+        url = reverse('send_email', kwargs={'course_id': self.course.id})
+        response = self.client.post(url, {
+            'send_to': 'staff',
+            'subject': 'test subject',
+        })
+        self.assertEqual(response.status_code, 400)
 
 
 @override_settings(MODULESTORE=TEST_DATA_MIXED_MODULESTORE)
diff --git a/lms/djangoapps/instructor/tests/test_email.py b/lms/djangoapps/instructor/tests/test_email.py
new file mode 100644
index 000000000000..de8832a62519
--- /dev/null
+++ b/lms/djangoapps/instructor/tests/test_email.py
@@ -0,0 +1,139 @@
+"""
+Unit tests for email feature flag in new instructor dashboard.
+Additionally tests that bulk email is always disabled for
+non-Mongo backed courses, regardless of email feature flag.
+"""
+
+from django.test.utils import override_settings
+from django.conf import settings
+from django.core.urlresolvers import reverse
+
+from courseware.tests.tests import TEST_DATA_MONGO_MODULESTORE
+from student.tests.factories import AdminFactory
+from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
+from xmodule.modulestore.tests.factories import CourseFactory
+from courseware.tests.modulestore_config import TEST_DATA_MIXED_MODULESTORE
+
+from mock import patch
+
+from bulk_email.models import CourseAuthorization
+
+
+@override_settings(MODULESTORE=TEST_DATA_MONGO_MODULESTORE)
+class TestNewInstructorDashboardEmailViewMongoBacked(ModuleStoreTestCase):
+    """
+    Check for email view on the new instructor dashboard
+    for Mongo-backed courses
+    """
+    def setUp(self):
+        self.course = CourseFactory.create()
+
+        # Create instructor account
+        instructor = AdminFactory.create()
+        self.client.login(username=instructor.username, password="test")
+
+        # URL for instructor dash
+        self.url = reverse('instructor_dashboard_2', kwargs={'course_id': self.course.id})
+        # URL for email view
+        self.email_link = '<a href="" data-section="send_email">Email</a>'
+
+    def tearDown(self):
+        """
+        Undo all patches.
+        """
+        patch.stopall()
+
+    # In order for bulk email to work, we must have both the ENABLE_INSTRUCTOR_EMAIL_FLAG
+    # set to True and for the course to be Mongo-backed.
+    # The flag is enabled and the course is Mongo-backed (should work)
+    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': False})
+    def test_email_flag_true_mongo_true(self):
+        # Assert that instructor email is enabled for this course - since REQUIRE_COURSE_EMAIL_AUTH is False,
+        # all courses should be authorized to use email.
+        self.assertTrue(CourseAuthorization.instructor_email_enabled(self.course.id))
+        # Assert that the URL for the email view is in the response
+        response = self.client.get(self.url)
+        self.assertIn(self.email_link, response.content)
+
+        send_to_label = '<label for="id_to">Send to:</label>'
+        self.assertTrue(send_to_label in response.content)
+        self.assertEqual(response.status_code, 200)
+
+    # The course is Mongo-backed but the flag is disabled (should not work)
+    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': False})
+    def test_email_flag_false_mongo_true(self):
+        # Assert that the URL for the email view is not in the response
+        response = self.client.get(self.url)
+        self.assertFalse(self.email_link in response.content)
+
+    # Flag is enabled, but we require course auth and haven't turned it on for this course
+    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
+    def test_course_not_authorized(self):
+        # Assert that instructor email is not enabled for this course
+        self.assertFalse(CourseAuthorization.instructor_email_enabled(self.course.id))
+        # Assert that the URL for the email view is not in the response
+        response = self.client.get(self.url)
+        self.assertFalse(self.email_link in response.content)
+
+    # Flag is enabled, we require course auth and turn it on for this course
+    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
+    def test_course_authorized(self):
+        # Assert that instructor email is not enabled for this course
+        self.assertFalse(CourseAuthorization.instructor_email_enabled(self.course.id))
+        # Assert that the URL for the email view is not in the response
+        response = self.client.get(self.url)
+        self.assertFalse(self.email_link in response.content)
+
+        # Authorize the course to use email
+        cauth = CourseAuthorization(course_id=self.course.id, email_enabled=True)
+        cauth.save()
+
+        # Assert that instructor email is enabled for this course
+        self.assertTrue(CourseAuthorization.instructor_email_enabled(self.course.id))
+        # Assert that the URL for the email view is not in the response
+        response = self.client.get(self.url)
+        self.assertTrue(self.email_link in response.content)
+
+    # Flag is disabled, but course is authorized
+    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': False, 'REQUIRE_COURSE_EMAIL_AUTH': True})
+    def test_course_authorized_feature_off(self):
+        # Authorize the course to use email
+        cauth = CourseAuthorization(course_id=self.course.id, email_enabled=True)
+        cauth.save()
+
+        # Assert that instructor email IS enabled for this course
+        self.assertTrue(CourseAuthorization.instructor_email_enabled(self.course.id))
+        # Assert that the URL for the email view IS NOT in the response
+        response = self.client.get(self.url)
+        self.assertFalse(self.email_link in response.content)
+
+
+@override_settings(MODULESTORE=TEST_DATA_MIXED_MODULESTORE)
+class TestNewInstructorDashboardEmailViewXMLBacked(ModuleStoreTestCase):
+    """
+    Check for email view on the new instructor dashboard
+    """
+    def setUp(self):
+        self.course_name = 'edX/toy/2012_Fall'
+
+        # Create instructor account
+        instructor = AdminFactory.create()
+        self.client.login(username=instructor.username, password="test")
+
+        # URL for instructor dash
+        self.url = reverse('instructor_dashboard_2', kwargs={'course_id': self.course_name})
+        # URL for email view
+        self.email_link = '<a href="" data-section="send_email">Email</a>'
+
+    # The flag is enabled, and since REQUIRE_COURSE_EMAIL_AUTH is False, all courses should
+    # be authorized to use email. But the course is not Mongo-backed (should not work)
+    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': False})
+    def test_email_flag_true_mongo_false(self):
+        response = self.client.get(self.url)
+        self.assertFalse(self.email_link in response.content)
+
+    # The flag is disabled and the course is not Mongo-backed (should not work)
+    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': False, 'REQUIRE_COURSE_EMAIL_AUTH': False})
+    def test_email_flag_false_mongo_false(self):
+        response = self.client.get(self.url)
+        self.assertFalse(self.email_link in response.content)
diff --git a/lms/djangoapps/instructor/tests/test_legacy_email.py b/lms/djangoapps/instructor/tests/test_legacy_email.py
index d8761466b0e7..20b8271bdffb 100644
--- a/lms/djangoapps/instructor/tests/test_legacy_email.py
+++ b/lms/djangoapps/instructor/tests/test_legacy_email.py
@@ -1,5 +1,5 @@
 """
-Unit tests for email feature flag in instructor dashboard
+Unit tests for email feature flag in legacy instructor dashboard
 and student dashboard. Additionally tests that bulk email
 is always disabled for non-Mongo backed courses, regardless
 of email feature flag.
@@ -41,7 +41,7 @@ def tearDown(self):
         """
         patch.stopall()
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True})
+    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': False})
     def test_email_flag_true(self):
         # Assert that the URL for the email view is in the response
         response = self.client.get(self.url)
diff --git a/lms/djangoapps/instructor/views/api.py b/lms/djangoapps/instructor/views/api.py
index e0b047604e14..facf64858056 100644
--- a/lms/djangoapps/instructor/views/api.py
+++ b/lms/djangoapps/instructor/views/api.py
@@ -9,7 +9,6 @@
 import re
 import logging
 import requests
-from collections import OrderedDict
 from django.conf import settings
 from django_future.csrf import ensure_csrf_cookie
 from django.views.decorators.cache import cache_control
@@ -40,6 +39,8 @@
 import analytics.csvs
 import csv
 
+from bulk_email.models import CourseEmail
+
 log = logging.getLogger(__name__)
 
 
@@ -95,7 +96,44 @@ def wrapped(*args, **kwargs):  # pylint: disable=C0111
             for (param, extra) in required_params:
                 default = object()
                 if request.GET.get(param, default) == default:
-                    error_response_data['parameters'] += [param]
+                    error_response_data['parameters'].append(param)
+                    error_response_data['info'][param] = extra
+
+            if len(error_response_data['parameters']) > 0:
+                return JsonResponse(error_response_data, status=400)
+            else:
+                return func(*args, **kwargs)
+        return wrapped
+    return decorator
+
+
+def require_post_params(*args, **kwargs):
+    """
+    Checks for required parameters or renders a 400 error.
+    (decorator with arguments)
+
+    Functions like 'require_query_params', but checks for
+    POST parameters rather than GET parameters.
+    """
+    required_params = []
+    required_params += [(arg, None) for arg in args]
+    required_params += [(key, kwargs[key]) for key in kwargs]
+    # required_params = e.g. [('action', 'enroll or unenroll'), ['emails', None]]
+
+    def decorator(func):  # pylint: disable=C0111
+        def wrapped(*args, **kwargs):  # pylint: disable=C0111
+            request = args[0]
+
+            error_response_data = {
+                'error': 'Missing required query parameter(s)',
+                'parameters': [],
+                'info': {},
+            }
+
+            for (param, extra) in required_params:
+                default = object()
+                if request.POST.get(param, default) == default:
+                    error_response_data['parameters'].append(param)
                     error_response_data['info'][param] = extra
 
             if len(error_response_data['parameters']) > 0:
@@ -397,7 +435,7 @@ def csv_response(filename, header, rows):
     students = User.objects.filter(
         courseenrollment__course_id=course_id,
     ).order_by('id')
-    header =['User ID', 'Anonymized user ID']
+    header = ['User ID', 'Anonymized user ID']
     rows = [[s.id, unique_id_for_user(s)] for s in students]
     return csv_response(course_id.replace('/', '-') + '-anon-ids.csv', header, rows)
 
@@ -706,6 +744,36 @@ def extract_user_info(user):
     return JsonResponse(response_payload)
 
 
+@ensure_csrf_cookie
+@cache_control(no_cache=True, no_store=True, must_revalidate=True)
+@require_level('staff')
+@require_post_params(send_to="sending to whom", subject="subject line", message="message text")
+def send_email(request, course_id):
+    """
+    Send an email to self, staff, or everyone involved in a course.
+    Query Parameters:
+    - 'send_to' specifies what group the email should be sent to
+       Options are defined by the CourseEmail model in
+       lms/djangoapps/bulk_email/models.py
+    - 'subject' specifies email's subject
+    - 'message' specifies email's content
+    """
+    send_to = request.POST.get("send_to")
+    subject = request.POST.get("subject")
+    message = request.POST.get("message")
+
+    # Create the CourseEmail object.  This is saved immediately, so that
+    # any transaction that has been pending up to this point will also be
+    # committed.
+    email = CourseEmail.create(course_id, request.user, send_to, subject, message)
+
+    # Submit the task, so that the correct InstructorTask object gets created (for monitoring purposes)
+    instructor_task.api.submit_bulk_course_email(request, course_id, email.id)  # pylint: disable=E1101
+
+    response_payload = {'course_id': course_id}
+    return JsonResponse(response_payload)
+
+
 @ensure_csrf_cookie
 @cache_control(no_cache=True, no_store=True, must_revalidate=True)
 @require_level('staff')
diff --git a/lms/djangoapps/instructor/views/api_urls.py b/lms/djangoapps/instructor/views/api_urls.py
index 07af69558f40..79cdcf7e69c6 100644
--- a/lms/djangoapps/instructor/views/api_urls.py
+++ b/lms/djangoapps/instructor/views/api_urls.py
@@ -2,7 +2,6 @@
 Instructor API endpoint urls.
 """
 
-
 from django.conf.urls import patterns, url
 
 urlpatterns = patterns('',  # nopep8
@@ -34,4 +33,6 @@
         'instructor.views.api.update_forum_role_membership', name="update_forum_role_membership"),
     url(r'^proxy_legacy_analytics$',
         'instructor.views.api.proxy_legacy_analytics', name="proxy_legacy_analytics"),
+    url(r'^send_email$',
+        'instructor.views.api.send_email', name="send_email")
 )
diff --git a/lms/djangoapps/instructor/views/instructor_dashboard.py b/lms/djangoapps/instructor/views/instructor_dashboard.py
index e248d47a593d..759d288ff324 100644
--- a/lms/djangoapps/instructor/views/instructor_dashboard.py
+++ b/lms/djangoapps/instructor/views/instructor_dashboard.py
@@ -9,14 +9,20 @@
 from django.core.urlresolvers import reverse
 from django.utils.html import escape
 from django.http import Http404
+from django.conf import settings
 
+from xmodule_modifiers import wrap_xmodule
+from xmodule.html_module import HtmlDescriptor
+from xmodule.modulestore import MONGO_MODULESTORE_TYPE
+from xmodule.modulestore.django import modulestore
+from xblock.field_data import DictFieldData
+from xblock.fields import ScopeIds
 from courseware.access import has_access
 from courseware.courses import get_course_by_id
 from django_comment_client.utils import has_forum_access
 from django_comment_common.models import FORUM_ROLE_ADMINISTRATOR
-from xmodule.modulestore.django import modulestore
 from student.models import CourseEnrollment
-
+from bulk_email.models import CourseAuthorization
 
 @ensure_csrf_cookie
 @cache_control(no_cache=True, no_store=True, must_revalidate=True)
@@ -24,6 +30,7 @@ def instructor_dashboard_2(request, course_id):
     """ Display the instructor dashboard for a course. """
 
     course = get_course_by_id(course_id, depth=None)
+    is_studio_course = (modulestore().get_modulestore_type(course_id) == MONGO_MODULESTORE_TYPE)
 
     access = {
         'admin': request.user.is_staff,
@@ -45,6 +52,11 @@ def instructor_dashboard_2(request, course_id):
         _section_analytics(course_id),
     ]
 
+    # Gate access by feature flag & by course-specific authorization
+    if settings.MITX_FEATURES['ENABLE_INSTRUCTOR_EMAIL'] and \
+       is_studio_course and CourseAuthorization.instructor_email_enabled(course_id):
+        sections.append(_section_send_email(course_id, access, course))
+
     context = {
         'course': course,
         'old_dashboard_url': reverse('instructor_dashboard', kwargs={'course_id': course_id}),
@@ -141,6 +153,20 @@ def _section_data_download(course_id):
     return section_data
 
 
+def _section_send_email(course_id, access, course):
+    """ Provide data for the corresponding bulk email section """
+    html_module = HtmlDescriptor(course.system, DictFieldData({'data': ''}), ScopeIds(None, None, None, None))
+    email_editor = wrap_xmodule(html_module.get_html, html_module, 'xmodule_edit.html')()
+    section_data = {
+        'section_key': 'send_email',
+        'section_display_name': _('Email'),
+        'access': access,
+        'send_email': reverse('send_email', kwargs={'course_id': course_id}),
+        'editor': email_editor
+    }
+    return section_data
+
+
 def _section_analytics(course_id):
     """ Provide data for the corresponding dashboard section """
     section_data = {
diff --git a/lms/djangoapps/instructor/views/legacy.py b/lms/djangoapps/instructor/views/legacy.py
index c7e32a52ae45..517d8be1d2c7 100644
--- a/lms/djangoapps/instructor/views/legacy.py
+++ b/lms/djangoapps/instructor/views/legacy.py
@@ -30,6 +30,7 @@
 from xmodule.modulestore.exceptions import ItemNotFoundError
 from xmodule.html_module import HtmlDescriptor
 
+from bulk_email.models import CourseEmail, CourseAuthorization
 from courseware import grades
 from courseware.access import (has_access, get_access_group_name,
                                course_beta_test_group_name)
@@ -46,7 +47,8 @@
                                  get_instructor_task_history,
                                  submit_rescore_problem_for_all_students,
                                  submit_rescore_problem_for_student,
-                                 submit_reset_problem_attempts_for_all_students)
+                                 submit_reset_problem_attempts_for_all_students,
+                                 submit_bulk_course_email)
 from instructor_task.views import get_task_completion_info
 from mitxmako.shortcuts import render_to_response
 from psychometrics import psychoanalyze
@@ -58,11 +60,6 @@
 from xblock.fields import ScopeIds
 from django.utils.translation import ugettext as _u
 
-from bulk_email.models import CourseEmail
-from html_to_text import html_to_text
-from bulk_email import tasks
-
-
 log = logging.getLogger(__name__)
 
 # internal commands for managing forum roles:
@@ -718,29 +715,24 @@ def getdat(u):
         email_to_option = request.POST.get("to_option")
         email_subject = request.POST.get("subject")
         html_message = request.POST.get("message")
-        text_message = html_to_text(html_message)
-
-        email = CourseEmail(
-            course_id=course_id,
-            sender=request.user,
-            to_option=email_to_option,
-            subject=email_subject,
-            html_message=html_message,
-            text_message=text_message
-        )
 
-        email.save()
+        # Create the CourseEmail object.  This is saved immediately, so that
+        # any transaction that has been pending up to this point will also be
+        # committed.
+        email = CourseEmail.create(course_id, request.user, email_to_option, email_subject, html_message)
 
-        tasks.delegate_email_batches.delay(
-            email.id,
-            request.user.id
-        )
+        # Submit the task, so that the correct InstructorTask object gets created (for monitoring purposes)
+        submit_bulk_course_email(request, course_id, email.id)  # pylint: disable=E1101
 
         if email_to_option == "all":
             email_msg = '<div class="msg msg-confirm"><p class="copy">Your email was successfully queued for sending. Please note that for large public classes (~10k), it may take 1-2 hours to send all emails.</p></div>'
         else:
             email_msg = '<div class="msg msg-confirm"><p class="copy">Your email was successfully queued for sending.</p></div>'
 
+    elif "Show Background Email Task History" in action:
+        message, datatable = get_background_task_table(course_id, task_type='bulk_course_email')
+        msg += message
+
     #----------------------------------------
     # psychometrics
 
@@ -806,23 +798,25 @@ def get_analytics_result(analytics_name):
     else:
         instructor_tasks = None
 
-    # determine if this is a studio-backed course so we can 1) provide a link to edit this course in studio
-    # 2) enable course email
+    # determine if this is a studio-backed course so we can provide a link to edit this course in studio
     is_studio_course = modulestore().get_modulestore_type(course_id) == MONGO_MODULESTORE_TYPE
 
+    studio_url = None
+    if is_studio_course:
+        studio_url = get_cms_course_link_by_id(course_id)
+
     email_editor = None
     # HTML editor for email
     if idash_mode == 'Email' and is_studio_course:
         html_module = HtmlDescriptor(course.system, DictFieldData({'data': html_message}), ScopeIds(None, None, None, None))
         email_editor = wrap_xmodule(html_module.get_html, html_module, 'xmodule_edit.html')()
 
-    studio_url = None
-    if is_studio_course:
-        studio_url = get_cms_course_link_by_id(course_id)
-
-    # Flag for whether or not we display the email tab (depending upon
-    # what backing store this course using (Mongo vs. XML))
-    if settings.MITX_FEATURES['ENABLE_INSTRUCTOR_EMAIL'] and is_studio_course:
+    # Enable instructor email only if the following conditions are met:
+    # 1. Feature flag is on
+    # 2. We have explicitly enabled email for the given course via django-admin
+    # 3. It is NOT an XML course
+    if settings.MITX_FEATURES['ENABLE_INSTRUCTOR_EMAIL'] and \
+       CourseAuthorization.instructor_email_enabled(course_id) and is_studio_course:
         show_email_tab = True
 
     # display course stats only if there is no other table to display:
@@ -865,6 +859,7 @@ def get_analytics_result(analytics_name):
 
     return render_to_response('courseware/instructor_dashboard.html', context)
 
+
 def _do_remote_gradebook(user, course, action, args=None, files=None):
     '''
     Perform remote gradebook action.  Returns msg, datatable.
@@ -1515,7 +1510,7 @@ def dump_grading_context(course):
     return msg
 
 
-def get_background_task_table(course_id, problem_url, student=None):
+def get_background_task_table(course_id, problem_url=None, student=None, task_type=None):
     """
     Construct the "datatable" structure to represent background task history.
 
@@ -1526,14 +1521,16 @@ def get_background_task_table(course_id, problem_url, student=None):
     Returns a tuple of (msg, datatable), where the msg is a possible error message,
     and the datatable is the datatable to be used for display.
     """
-    history_entries = get_instructor_task_history(course_id, problem_url, student)
+    history_entries = get_instructor_task_history(course_id, problem_url, student, task_type)
     datatable = {}
     msg = ""
     # first check to see if there is any history at all
     # (note that we don't have to check that the arguments are valid; it
     # just won't find any entries.)
     if (history_entries.count()) == 0:
-        if student is not None:
+        if problem_url is None:
+            msg += '<font color="red">Failed to find any background tasks for course "{course}".</font>'.format(course=course_id)
+        elif student is not None:
             template = '<font color="red">Failed to find any background tasks for course "{course}", module "{problem}" and student "{student}".</font>'
             msg += template.format(course=course_id, problem=problem_url, student=student.username)
         else:
@@ -1570,7 +1567,9 @@ def get_background_task_table(course_id, problem_url, student=None):
                    task_message]
             datatable['data'].append(row)
 
-        if student is not None:
+        if problem_url is None:
+            datatable['title'] = "{course_id}".format(course_id=course_id)
+        elif student is not None:
             datatable['title'] = "{course_id} > {location} > {student}".format(course_id=course_id,
                                                                                location=problem_url,
                                                                                student=student.username)
diff --git a/lms/djangoapps/instructor_task/api.py b/lms/djangoapps/instructor_task/api.py
index bd3c5e033a8f..7521a8eb3a3b 100644
--- a/lms/djangoapps/instructor_task/api.py
+++ b/lms/djangoapps/instructor_task/api.py
@@ -6,6 +6,7 @@
 arguments.
 
 """
+import hashlib
 
 from celery.states import READY_STATES
 
@@ -14,11 +15,13 @@
 from instructor_task.models import InstructorTask
 from instructor_task.tasks import (rescore_problem,
                                    reset_problem_attempts,
-                                   delete_problem_state)
+                                   delete_problem_state,
+                                   send_bulk_course_email)
 
 from instructor_task.api_helper import (check_arguments_for_rescoring,
                                         encode_problem_and_student_input,
                                         submit_task)
+from bulk_email.models import CourseEmail
 
 
 def get_running_instructor_tasks(course_id):
@@ -34,14 +37,18 @@ def get_running_instructor_tasks(course_id):
     return instructor_tasks.order_by('-id')
 
 
-def get_instructor_task_history(course_id, problem_url, student=None):
+def get_instructor_task_history(course_id, problem_url=None, student=None, task_type=None):
     """
     Returns a query of InstructorTask objects of historical tasks for a given course,
-    that match a particular problem and optionally a student.
+    that optionally match a particular problem, a student, and/or a task type.
     """
-    _, task_key = encode_problem_and_student_input(problem_url, student)
+    instructor_tasks = InstructorTask.objects.filter(course_id=course_id)
+    if problem_url is not None or student is not None:
+        _, task_key = encode_problem_and_student_input(problem_url, student)
+        instructor_tasks = instructor_tasks.filter(task_key=task_key)
+    if task_type is not None:
+        instructor_tasks = instructor_tasks.filter(task_type=task_type)
 
-    instructor_tasks = InstructorTask.objects.filter(course_id=course_id, task_key=task_key)
     return instructor_tasks.order_by('-id')
 
 
@@ -162,3 +169,40 @@ def submit_delete_problem_state_for_all_students(request, course_id, problem_url
     task_class = delete_problem_state
     task_input, task_key = encode_problem_and_student_input(problem_url)
     return submit_task(request, task_type, task_class, course_id, task_input, task_key)
+
+
+def submit_bulk_course_email(request, course_id, email_id):
+    """
+    Request to have bulk email sent as a background task.
+
+    The specified CourseEmail object will be sent be updated for all students who have enrolled
+    in a course.  Parameters are the `course_id` and the `email_id`, the id of the CourseEmail object.
+
+    AlreadyRunningError is raised if the same recipients are already being emailed with the same
+    CourseEmail object.
+
+    This method makes sure the InstructorTask entry is committed.
+    When called from any view that is wrapped by TransactionMiddleware,
+    and thus in a "commit-on-success" transaction, an autocommit buried within here
+    will cause any pending transaction to be committed by a successful
+    save here.  Any future database operations will take place in a
+    separate transaction.
+    """
+    # Assume that the course is defined, and that the user has already been verified to have
+    # appropriate access to the course. But make sure that the email exists.
+    # We also pull out the To argument here, so that is displayed in
+    # the InstructorTask status.
+    email_obj = CourseEmail.objects.get(id=email_id)
+    to_option = email_obj.to_option
+
+    task_type = 'bulk_course_email'
+    task_class = send_bulk_course_email
+    # Pass in the to_option as a separate argument, even though it's (currently)
+    # in the CourseEmail.  That way it's visible in the progress status.
+    # (At some point in the future, we might take the recipient out of the CourseEmail,
+    # so that the same saved email can be sent to different recipients, as it is tested.)
+    task_input = {'email_id': email_id, 'to_option': to_option}
+    task_key_stub = "{email_id}_{to_option}".format(email_id=email_id, to_option=to_option)
+    # create the key value by using MD5 hash:
+    task_key = hashlib.md5(task_key_stub).hexdigest()
+    return submit_task(request, task_type, task_class, course_id, task_input, task_key)
diff --git a/lms/djangoapps/instructor_task/api_helper.py b/lms/djangoapps/instructor_task/api_helper.py
index 2795fd08c1d8..37a9852caa2a 100644
--- a/lms/djangoapps/instructor_task/api_helper.py
+++ b/lms/djangoapps/instructor_task/api_helper.py
@@ -58,13 +58,14 @@ def _reserve_task(course_id, task_type, task_key, task_input, requester):
     return InstructorTask.create(course_id, task_type, task_key, task_input, requester)
 
 
-def _get_xmodule_instance_args(request):
+def _get_xmodule_instance_args(request, task_id):
     """
     Calculate parameters needed for instantiating xmodule instances.
 
     The `request_info` will be passed to a tracking log function, to provide information
     about the source of the task request.   The `xqueue_callback_url_prefix` is used to
     permit old-style xqueue callbacks directly to the appropriate module in the LMS.
+    The `task_id` is also passed to the tracking log function.
     """
     request_info = {'username': request.user.username,
                     'ip': request.META['REMOTE_ADDR'],
@@ -74,6 +75,7 @@ def _get_xmodule_instance_args(request):
 
     xmodule_instance_args = {'xqueue_callback_url_prefix': get_xqueue_callback_url_prefix(request),
                              'request_info': request_info,
+                             'task_id': task_id,
                              }
     return xmodule_instance_args
 
@@ -88,10 +90,16 @@ def _update_instructor_task(instructor_task, task_result):
     is usually not saved.  In general, tasks that have finished (either with
     success or failure) should have their entries updated by the task itself,
     so are not updated here.  Tasks that are still running are not updated
-    while they run.  So the one exception to the no-save rule are tasks that
+    and saved while they run.  The one exception to the no-save rule are tasks that
     are in a "revoked" state.  This may mean that the task never had the
     opportunity to update the InstructorTask entry.
 
+    Tasks that are in progress and have subtasks doing the processing do not look
+    to the task's AsyncResult object.  When subtasks are running, the
+    InstructorTask object itself is updated with the subtasks' progress,
+    not any AsyncResult object.  In this case, the InstructorTask is
+    not updated at all.
+
     Calculates json to store in "task_output" field of the `instructor_task`,
     as well as updating the task_state.
 
@@ -108,11 +116,21 @@ def _update_instructor_task(instructor_task, task_result):
     returned_result = task_result.result
     result_traceback = task_result.traceback
 
-    # Assume we don't always update the InstructorTask entry if we don't have to:
+    # Assume we don't always save the InstructorTask entry if we don't have to,
+    # but that in most cases we will update the InstructorTask in-place with its
+    # current progress.
+    entry_needs_updating = True
     entry_needs_saving = False
     task_output = None
 
-    if result_state in [PROGRESS, SUCCESS]:
+    if instructor_task.task_state == PROGRESS and len(instructor_task.subtasks) > 0:
+        # This happens when running subtasks:  the result object is marked with SUCCESS,
+        # meaning that the subtasks have successfully been defined.  However, the InstructorTask
+        # will be marked as in PROGRESS, until the last subtask completes and marks it as SUCCESS.
+        # We want to ignore the parent SUCCESS if subtasks are still running, and just trust the
+        # contents of the InstructorTask.
+        entry_needs_updating = False
+    elif result_state in [PROGRESS, SUCCESS]:
         # construct a status message directly from the task result's result:
         # it needs to go back with the entry passed in.
         log.info("background task (%s), state %s:  result: %s", task_id, result_state, returned_result)
@@ -134,12 +152,13 @@ def _update_instructor_task(instructor_task, task_result):
     # save progress and state into the entry, even if it's not being saved:
     # when celery is run in "ALWAYS_EAGER" mode, progress needs to go back
     # with the entry passed in.
-    instructor_task.task_state = result_state
-    if task_output is not None:
-        instructor_task.task_output = task_output
+    if entry_needs_updating:
+        instructor_task.task_state = result_state
+        if task_output is not None:
+            instructor_task.task_output = task_output
 
-    if entry_needs_saving:
-        instructor_task.save()
+        if entry_needs_saving:
+            instructor_task.save()
 
 
 def get_updated_instructor_task(task_id):
@@ -175,7 +194,7 @@ def get_status_from_instructor_task(instructor_task):
       'in_progress': boolean indicating if task is still running.
       'task_progress': dict containing progress information.  This includes:
           'attempted': number of attempts made
-          'updated': number of attempts that "succeeded"
+          'succeeded': number of attempts that "succeeded"
           'total': number of possible subtasks to attempt
           'action_name': user-visible verb to use in status messages.  Should be past-tense.
           'duration_ms': how long the task has (or had) been running.
@@ -214,7 +233,7 @@ def check_arguments_for_rescoring(course_id, problem_url):
 
 def encode_problem_and_student_input(problem_url, student=None):
     """
-    Encode problem_url and optional student into task_key and task_input values.
+    Encode optional problem_url and optional student into task_key and task_input values.
 
     `problem_url` is full URL of the problem.
     `student` is the user object of the student
@@ -257,7 +276,7 @@ def submit_task(request, task_type, task_class, course_id, task_input, task_key)
 
     # submit task:
     task_id = instructor_task.task_id
-    task_args = [instructor_task.id, _get_xmodule_instance_args(request)]
+    task_args = [instructor_task.id, _get_xmodule_instance_args(request, task_id)]  # pylint: disable=E1101
     task_class.apply_async(task_args, task_id=task_id)
 
     return instructor_task
diff --git a/lms/djangoapps/instructor_task/migrations/0002_add_subtask_field.py b/lms/djangoapps/instructor_task/migrations/0002_add_subtask_field.py
new file mode 100644
index 000000000000..845dffd85651
--- /dev/null
+++ b/lms/djangoapps/instructor_task/migrations/0002_add_subtask_field.py
@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+import datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Adding field 'InstructorTask.subtasks'
+        db.add_column('instructor_task_instructortask', 'subtasks',
+                      self.gf('django.db.models.fields.TextField')(default='', blank=True),
+                      keep_default=False)
+
+
+    def backwards(self, orm):
+        # Deleting field 'InstructorTask.subtasks'
+        db.delete_column('instructor_task_instructortask', 'subtasks')
+
+
+    models = {
+        'auth.group': {
+            'Meta': {'object_name': 'Group'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
+            'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
+        },
+        'auth.permission': {
+            'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'},
+            'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
+        },
+        'auth.user': {
+            'Meta': {'object_name': 'User'},
+            'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
+            'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
+            'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
+            'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
+        },
+        'contenttypes.contenttype': {
+            'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
+            'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
+        },
+        'instructor_task.instructortask': {
+            'Meta': {'object_name': 'InstructorTask'},
+            'course_id': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'null': 'True', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'requester': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']"}),
+            'subtasks': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            'task_id': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'}),
+            'task_input': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            'task_key': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'}),
+            'task_output': ('django.db.models.fields.CharField', [], {'max_length': '1024', 'null': 'True'}),
+            'task_state': ('django.db.models.fields.CharField', [], {'max_length': '50', 'null': 'True', 'db_index': 'True'}),
+            'task_type': ('django.db.models.fields.CharField', [], {'max_length': '50', 'db_index': 'True'}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'})
+        }
+    }
+
+    complete_apps = ['instructor_task']
\ No newline at end of file
diff --git a/lms/djangoapps/instructor_task/models.py b/lms/djangoapps/instructor_task/models.py
index b28a9a3d83d1..8d6376fae3ef 100644
--- a/lms/djangoapps/instructor_task/models.py
+++ b/lms/djangoapps/instructor_task/models.py
@@ -56,6 +56,7 @@ class InstructorTask(models.Model):
     requester = models.ForeignKey(User, db_index=True)
     created = models.DateTimeField(auto_now_add=True, null=True)
     updated = models.DateTimeField(auto_now=True)
+    subtasks = models.TextField(blank=True)  # JSON dictionary
 
     def __repr__(self):
         return 'InstructorTask<%r>' % ({
diff --git a/lms/djangoapps/instructor_task/subtasks.py b/lms/djangoapps/instructor_task/subtasks.py
new file mode 100644
index 000000000000..175cf084a52f
--- /dev/null
+++ b/lms/djangoapps/instructor_task/subtasks.py
@@ -0,0 +1,270 @@
+"""
+This module contains celery task functions for handling the management of subtasks.
+"""
+from time import time
+import json
+
+from celery.utils.log import get_task_logger
+from celery.states import SUCCESS, READY_STATES
+
+from django.db import transaction
+
+from instructor_task.models import InstructorTask, PROGRESS, QUEUING
+
+TASK_LOG = get_task_logger(__name__)
+
+
+def create_subtask_status(task_id, succeeded=0, failed=0, skipped=0, retried_nomax=0, retried_withmax=0, state=None):
+    """
+    Create and return a dict for tracking the status of a subtask.
+
+    Subtask status keys are:
+
+      'task_id' : id of subtask.  This is used to pass task information across retries.
+      'attempted' : number of attempts -- should equal succeeded plus failed
+      'succeeded' : number that succeeded in processing
+      'skipped' : number that were not processed.
+      'failed' : number that failed during processing
+      'retried_nomax' : number of times the subtask has been retried for conditions that
+          should not have a maximum count applied
+      'retried_withmax' : number of times the subtask has been retried for conditions that
+          should have a maximum count applied
+      'state' : celery state of the subtask (e.g. QUEUING, PROGRESS, RETRY, FAILURE, SUCCESS)
+
+    Object must be JSON-serializable, so that it can be passed as an argument
+    to tasks.
+
+    In future, we may want to include specific error information
+    indicating the reason for failure.
+    Also, we should count up "not attempted" separately from attempted/failed.
+    """
+    attempted = succeeded + failed
+    current_result = {
+        'task_id': task_id,
+        'attempted': attempted,
+        'succeeded': succeeded,
+        'skipped': skipped,
+        'failed': failed,
+        'retried_nomax': retried_nomax,
+        'retried_withmax': retried_withmax,
+        'state': state if state is not None else QUEUING,
+    }
+    return current_result
+
+
+def increment_subtask_status(subtask_result, succeeded=0, failed=0, skipped=0, retried_nomax=0, retried_withmax=0, state=None):
+    """
+    Update the result of a subtask with additional results.
+
+    Create and return a dict for tracking the status of a subtask.
+
+    Keys for input `subtask_result` and returned subtask_status are:
+
+      'task_id' : id of subtask.  This is used to pass task information across retries.
+      'attempted' : number of attempts -- should equal succeeded plus failed
+      'succeeded' : number that succeeded in processing
+      'skipped' : number that were not processed.
+      'failed' : number that failed during processing
+      'retried_nomax' : number of times the subtask has been retried for conditions that
+          should not have a maximum count applied
+      'retried_withmax' : number of times the subtask has been retried for conditions that
+          should have a maximum count applied
+      'state' : celery state of the subtask (e.g. QUEUING, PROGRESS, RETRY, FAILURE, SUCCESS)
+
+    Kwarg arguments are incremented to the corresponding key in `subtask_result`.
+    The exception is for `state`, which if specified is used to override the existing value.
+    """
+    new_result = dict(subtask_result)
+    new_result['attempted'] += (succeeded + failed)
+    new_result['succeeded'] += succeeded
+    new_result['failed'] += failed
+    new_result['skipped'] += skipped
+    new_result['retried_nomax'] += retried_nomax
+    new_result['retried_withmax'] += retried_withmax
+    if state is not None:
+        new_result['state'] = state
+
+    return new_result
+
+
+def initialize_subtask_info(entry, action_name, total_num, subtask_id_list):
+    """
+    Store initial subtask information to InstructorTask object.
+
+    The InstructorTask's "task_output" field is initialized.  This is a JSON-serialized dict.
+    Counters for 'attempted', 'succeeded', 'failed', 'skipped' keys are initialized to zero,
+    as is the 'duration_ms' value.  A 'start_time' is stored for later duration calculations,
+    and the total number of "things to do" is set, so the user can be told how much needs to be
+    done overall.  The `action_name` is also stored, to help with constructing more readable
+    task_progress messages.
+
+    The InstructorTask's "subtasks" field is also initialized.  This is also a JSON-serialized dict.
+    Keys include 'total', 'succeeded', 'retried', 'failed', which are counters for the number of
+    subtasks.  'Total' is set here to the total number, while the other three are initialized to zero.
+    Once the counters for 'succeeded' and 'failed' match the 'total', the subtasks are done and
+    the InstructorTask's "status" will be changed to SUCCESS.
+
+    The "subtasks" field also contains a 'status' key, that contains a dict that stores status
+    information for each subtask.  The value for each subtask (keyed by its task_id)
+    is its subtask status, as defined by create_subtask_status().
+
+    This information needs to be set up in the InstructorTask before any of the subtasks start
+    running.  If not, there is a chance that the subtasks could complete before the parent task
+    is done creating subtasks.  Doing so also simplifies the save() here, as it avoids the need
+    for locking.
+
+    Monitoring code should assume that if an InstructorTask has subtask information, that it should
+    rely on the status stored in the InstructorTask object, rather than status stored in the
+    corresponding AsyncResult.
+    """
+    task_progress = {
+        'action_name': action_name,
+        'attempted': 0,
+        'failed': 0,
+        'skipped': 0,
+        'succeeded': 0,
+        'total': total_num,
+        'duration_ms': int(0),
+        'start_time': time()
+    }
+    entry.task_output = InstructorTask.create_output_for_success(task_progress)
+    entry.task_state = PROGRESS
+
+    # Write out the subtasks information.
+    num_subtasks = len(subtask_id_list)
+    # Note that may not be necessary to store initial value with all those zeroes!
+    subtask_status = {subtask_id: create_subtask_status(subtask_id) for subtask_id in subtask_id_list}
+    subtask_dict = {
+        'total': num_subtasks,
+        'succeeded': 0,
+        'failed': 0,
+        'status': subtask_status
+    }
+    entry.subtasks = json.dumps(subtask_dict)
+
+    # and save the entry immediately, before any subtasks actually start work:
+    entry.save_now()
+    return task_progress
+
+
+def check_subtask_is_valid(entry_id, current_task_id):
+    """
+    Confirms that the current subtask is known to the InstructorTask.
+
+    This may happen if a task that spawns subtasks is called twice with
+    the same task_id and InstructorTask entry_id.  The set of subtasks
+    that are recorded in the InstructorTask from the first call get clobbered
+    by the the second set of subtasks.  So when the first set of subtasks
+    actually run, they won't be found in the InstructorTask.
+
+    Raises a ValueError exception if not.
+    """
+    entry = InstructorTask.objects.get(pk=entry_id)
+    if len(entry.subtasks) == 0:
+        format_str = "Unexpected task_id '{}': unable to find email subtasks of instructor task '{}'"
+        msg = format_str.format(current_task_id, entry)
+        TASK_LOG.warning(msg)
+        raise ValueError(msg)
+
+    subtask_dict = json.loads(entry.subtasks)
+    subtask_status_info = subtask_dict['status']
+    if current_task_id not in subtask_status_info:
+        format_str = "Unexpected task_id '{}': unable to find status for email subtask of instructor task '{}'"
+        msg = format_str.format(current_task_id, entry)
+        TASK_LOG.warning(msg)
+        raise ValueError(msg)
+
+
+@transaction.commit_manually
+def update_subtask_status(entry_id, current_task_id, new_subtask_status):
+    """
+    Update the status of the subtask in the parent InstructorTask object tracking its progress.
+
+    Uses select_for_update to lock the InstructorTask object while it is being updated.
+    The operation is surrounded by a try/except/else that permit the manual transaction to be
+    committed on completion, or rolled back on error.
+
+    The InstructorTask's "task_output" field is updated.  This is a JSON-serialized dict.
+    Accumulates values for 'attempted', 'succeeded', 'failed', 'skipped' from `new_subtask_status`
+    into the corresponding values in the InstructorTask's task_output.  Also updates the 'duration_ms'
+    value with the current interval since the original InstructorTask started.  Note that this
+    value is only approximate, since the subtask may be running on a different server than the
+    original task, so is subject to clock skew.
+
+    The InstructorTask's "subtasks" field is also updated.  This is also a JSON-serialized dict.
+    Keys include 'total', 'succeeded', 'retried', 'failed', which are counters for the number of
+    subtasks.  'Total' is expected to have been set at the time the subtasks were created.
+    The other three counters are incremented depending on the value of `status`.  Once the counters
+    for 'succeeded' and 'failed' match the 'total', the subtasks are done and the InstructorTask's
+    "status" is changed to SUCCESS.
+
+    The "subtasks" field also contains a 'status' key, that contains a dict that stores status
+    information for each subtask.  At the moment, the value for each subtask (keyed by its task_id)
+    is the value of `status`, but could be expanded in future to store information about failure
+    messages, progress made, etc.
+    """
+    TASK_LOG.info("Preparing to update status for email subtask %s for instructor task %d with status %s",
+                  current_task_id, entry_id, new_subtask_status)
+
+    try:
+        entry = InstructorTask.objects.select_for_update().get(pk=entry_id)
+        subtask_dict = json.loads(entry.subtasks)
+        subtask_status_info = subtask_dict['status']
+        if current_task_id not in subtask_status_info:
+            # unexpected error -- raise an exception
+            format_str = "Unexpected task_id '{}': unable to update status for email subtask of instructor task '{}'"
+            msg = format_str.format(current_task_id, entry_id)
+            TASK_LOG.warning(msg)
+            raise ValueError(msg)
+
+        # Update status:
+        subtask_status_info[current_task_id] = new_subtask_status
+
+        # Update the parent task progress.
+        # Set the estimate of duration, but only if it
+        # increases.  Clock skew between time() returned by different machines
+        # may result in non-monotonic values for duration.
+        task_progress = json.loads(entry.task_output)
+        start_time = task_progress['start_time']
+        prev_duration = task_progress['duration_ms']
+        new_duration = int((time() - start_time) * 1000)
+        task_progress['duration_ms'] = max(prev_duration, new_duration)
+
+        # Update counts only when subtask is done.
+        # In future, we can make this more responsive by updating status
+        # between retries, by comparing counts that change from previous
+        # retry.
+        new_state = new_subtask_status['state']
+        if new_subtask_status is not None and new_state in READY_STATES:
+            for statname in ['attempted', 'succeeded', 'failed', 'skipped']:
+                task_progress[statname] += new_subtask_status[statname]
+
+        # Figure out if we're actually done (i.e. this is the last task to complete).
+        # This is easier if we just maintain a counter, rather than scanning the
+        # entire new_subtask_status dict.
+        if new_state == SUCCESS:
+            subtask_dict['succeeded'] += 1
+        elif new_state in READY_STATES:
+            subtask_dict['failed'] += 1
+        num_remaining = subtask_dict['total'] - subtask_dict['succeeded'] - subtask_dict['failed']
+
+        # If we're done with the last task, update the parent status to indicate that.
+        # At present, we mark the task as having succeeded.  In future, we should see
+        # if there was a catastrophic failure that occurred, and figure out how to
+        # report that here.
+        if num_remaining <= 0:
+            entry.task_state = SUCCESS
+        entry.subtasks = json.dumps(subtask_dict)
+        entry.task_output = InstructorTask.create_output_for_success(task_progress)
+
+        TASK_LOG.info("Task output updated to %s for email subtask %s of instructor task %d",
+                      entry.task_output, current_task_id, entry_id)
+        TASK_LOG.debug("about to save....")
+        entry.save()
+    except Exception:
+        TASK_LOG.exception("Unexpected error while updating InstructorTask.")
+        transaction.rollback()
+        raise
+    else:
+        TASK_LOG.debug("about to commit....")
+        transaction.commit()
diff --git a/lms/djangoapps/instructor_task/tasks.py b/lms/djangoapps/instructor_task/tasks.py
index b045de470ac3..f30ffe3af2f2 100644
--- a/lms/djangoapps/instructor_task/tasks.py
+++ b/lms/djangoapps/instructor_task/tasks.py
@@ -19,14 +19,21 @@
 of the query for traversing StudentModule objects.
 
 """
+from django.utils.translation import ugettext_noop
 from celery import task
-from instructor_task.tasks_helper import (update_problem_module_state,
-                                          rescore_problem_module_state,
-                                          reset_attempts_module_state,
-                                          delete_problem_module_state)
-
-
-@task
+from functools import partial
+from instructor_task.tasks_helper import (
+    run_main_task,
+    BaseInstructorTask,
+    perform_module_state_update,
+    rescore_problem_module_state,
+    reset_attempts_module_state,
+    delete_problem_module_state,
+)
+from bulk_email.tasks import perform_delegate_email_batches
+
+
+@task(base=BaseInstructorTask)  # pylint: disable=E1102
 def rescore_problem(entry_id, xmodule_instance_args):
     """Rescores a problem in a course, for all students or one specific student.
 
@@ -45,15 +52,19 @@ def rescore_problem(entry_id, xmodule_instance_args):
     `xmodule_instance_args` provides information needed by _get_module_instance_for_task()
     to instantiate an xmodule instance.
     """
-    action_name = 'rescored'
-    update_fcn = rescore_problem_module_state
-    filter_fcn = lambda(modules_to_update): modules_to_update.filter(state__contains='"done": true')
-    return update_problem_module_state(entry_id,
-                                       update_fcn, action_name, filter_fcn=filter_fcn,
-                                       xmodule_instance_args=xmodule_instance_args)
+    # Translators: This is a past-tense verb that is inserted into task progress messages as {action}.
+    action_name = ugettext_noop('rescored')
+    update_fcn = partial(rescore_problem_module_state, xmodule_instance_args)
+
+    def filter_fcn(modules_to_update):
+        """Filter that matches problems which are marked as being done"""
+        return modules_to_update.filter(state__contains='"done": true')
+
+    visit_fcn = partial(perform_module_state_update, update_fcn, filter_fcn)
+    return run_main_task(entry_id, visit_fcn, action_name)
 
 
-@task
+@task(base=BaseInstructorTask)  # pylint: disable=E1102
 def reset_problem_attempts(entry_id, xmodule_instance_args):
     """Resets problem attempts to zero for a particular problem for all students in a course.
 
@@ -68,14 +79,14 @@ def reset_problem_attempts(entry_id, xmodule_instance_args):
     `xmodule_instance_args` provides information needed by _get_module_instance_for_task()
     to instantiate an xmodule instance.
     """
-    action_name = 'reset'
-    update_fcn = reset_attempts_module_state
-    return update_problem_module_state(entry_id,
-                                       update_fcn, action_name, filter_fcn=None,
-                                       xmodule_instance_args=xmodule_instance_args)
+    # Translators: This is a past-tense verb that is inserted into task progress messages as {action}.
+    action_name = ugettext_noop('reset')
+    update_fcn = partial(reset_attempts_module_state, xmodule_instance_args)
+    visit_fcn = partial(perform_module_state_update, update_fcn, None)
+    return run_main_task(entry_id, visit_fcn, action_name)
 
 
-@task
+@task(base=BaseInstructorTask)  # pylint: disable=E1102
 def delete_problem_state(entry_id, xmodule_instance_args):
     """Deletes problem state entirely for all students on a particular problem in a course.
 
@@ -90,8 +101,29 @@ def delete_problem_state(entry_id, xmodule_instance_args):
     `xmodule_instance_args` provides information needed by _get_module_instance_for_task()
     to instantiate an xmodule instance.
     """
-    action_name = 'deleted'
-    update_fcn = delete_problem_module_state
-    return update_problem_module_state(entry_id,
-                                       update_fcn, action_name, filter_fcn=None,
-                                       xmodule_instance_args=xmodule_instance_args)
+    # Translators: This is a past-tense verb that is inserted into task progress messages as {action}.
+    action_name = ugettext_noop('deleted')
+    update_fcn = partial(delete_problem_module_state, xmodule_instance_args)
+    visit_fcn = partial(perform_module_state_update, update_fcn, None)
+    return run_main_task(entry_id, visit_fcn, action_name)
+
+
+@task(base=BaseInstructorTask)  # pylint: disable=E1102
+def send_bulk_course_email(entry_id, _xmodule_instance_args):
+    """Sends emails to recipients enrolled in a course.
+
+    `entry_id` is the id value of the InstructorTask entry that corresponds to this task.
+    The entry contains the `course_id` that identifies the course, as well as the
+    `task_input`, which contains task-specific input.
+
+    The task_input should be a dict with the following entries:
+
+      'email_id': the full URL to the problem to be rescored.  (required)
+
+    `_xmodule_instance_args` provides information needed by _get_module_instance_for_task()
+    to instantiate an xmodule instance.  This is unused here.
+    """
+    # Translators: This is a past-tense verb that is inserted into task progress messages as {action}.
+    action_name = ugettext_noop('emailed')
+    visit_fcn = perform_delegate_email_batches
+    return run_main_task(entry_id, visit_fcn, action_name)
diff --git a/lms/djangoapps/instructor_task/tasks_helper.py b/lms/djangoapps/instructor_task/tasks_helper.py
index 4f2d37a212cc..f6e887b1d270 100644
--- a/lms/djangoapps/instructor_task/tasks_helper.py
+++ b/lms/djangoapps/instructor_task/tasks_helper.py
@@ -3,19 +3,15 @@
 running state of a course.
 
 """
-
 import json
 from time import time
-from sys import exc_info
-from traceback import format_exc
 
-from celery import current_task
+from celery import Task, current_task
 from celery.utils.log import get_task_logger
-from celery.signals import worker_process_init
 from celery.states import SUCCESS, FAILURE
 
 from django.contrib.auth.models import User
-from django.db import transaction
+from django.db import transaction, reset_queries
 from dogapi import dog_stats_api
 
 from xmodule.modulestore.django import modulestore
@@ -33,6 +29,96 @@
 # define value to use when no task_id is provided:
 UNKNOWN_TASK_ID = 'unknown-task_id'
 
+# define values for update functions to use to return status to perform_module_state_update
+UPDATE_STATUS_SUCCEEDED = 'succeeded'
+UPDATE_STATUS_FAILED = 'failed'
+UPDATE_STATUS_SKIPPED = 'skipped'
+
+
+class BaseInstructorTask(Task):
+    """
+    Base task class for use with InstructorTask models.
+
+    Permits updating information about task in corresponding InstructorTask for monitoring purposes.
+
+    Assumes that the entry_id of the InstructorTask model is the first argument to the task.
+
+    The `entry_id` is the primary key for the InstructorTask entry representing the task.  This class
+    updates the entry on success and failure of the task it wraps.  It is setting the entry's value
+    for task_state based on what Celery would set it to once the task returns to Celery:
+    FAILURE if an exception is encountered, and SUCCESS if it returns normally.
+    Other arguments are pass-throughs to perform_module_state_update, and documented there.
+    """
+    abstract = True
+
+    def on_success(self, task_progress, task_id, args, kwargs):
+        """
+        Update InstructorTask object corresponding to this task with info about success.
+
+        Updates task_output and task_state.  But it shouldn't actually do anything
+        if the task is only creating subtasks to actually do the work.
+
+        Assumes `task_progress` is a dict containing the task's result, with the following keys:
+
+          'attempted': number of attempts made
+          'succeeded': number of attempts that "succeeded"
+          'skipped': number of attempts that "skipped"
+          'failed': number of attempts that "failed"
+          'total': number of possible subtasks to attempt
+          'action_name': user-visible verb to use in status messages.  Should be past-tense.
+              Pass-through of input `action_name`.
+          'duration_ms': how long the task has (or had) been running.
+
+        This is JSON-serialized and stored in the task_output column of the InstructorTask entry.
+
+        """
+        TASK_LOG.debug('Task %s: success returned with progress: %s', task_id, task_progress)
+        # We should be able to find the InstructorTask object to update
+        # based on the task_id here, without having to dig into the
+        # original args to the task.  On the other hand, the entry_id
+        # is the first value passed to all such args, so we'll use that.
+        # And we assume that it exists, else we would already have had a failure.
+        entry_id = args[0]
+        entry = InstructorTask.objects.get(pk=entry_id)
+        # Check to see if any subtasks had been defined as part of this task.
+        # If not, then we know that we're done.  (If so, let the subtasks
+        # handle updating task_state themselves.)
+        if len(entry.subtasks) == 0:
+            entry.task_output = InstructorTask.create_output_for_success(task_progress)
+            entry.task_state = SUCCESS
+            entry.save_now()
+
+    def on_failure(self, exc, task_id, args, kwargs, einfo):
+        """
+        Update InstructorTask object corresponding to this task with info about failure.
+
+        Fetches and updates exception and traceback information on failure.
+
+        If an exception is raised internal to the task, it is caught by celery and provided here.
+        The information is recorded in the InstructorTask object as a JSON-serialized dict
+        stored in the task_output column.  It contains the following keys:
+
+               'exception':  type of exception object
+               'message': error message from exception object
+               'traceback': traceback information (truncated if necessary)
+
+        Note that there is no way to record progress made within the task (e.g. attempted,
+        succeeded, etc.) when such failures occur.
+        """
+        TASK_LOG.debug('Task %s: failure returned', task_id)
+        entry_id = args[0]
+        try:
+            entry = InstructorTask.objects.get(pk=entry_id)
+        except InstructorTask.DoesNotExist:
+            # if the InstructorTask object does not exist, then there's no point
+            # trying to update it.
+            TASK_LOG.error("Task (%s) has no InstructorTask object for id %s", task_id, entry_id)
+        else:
+            TASK_LOG.warning("Task (%s) failed: %s %s", task_id, einfo.exception, einfo.traceback)
+            entry.task_output = InstructorTask.create_output_for_failure(einfo.exception, einfo.traceback)
+            entry.task_state = FAILURE
+            entry.save_now()
+
 
 class UpdateProblemModuleStateError(Exception):
     """
@@ -45,12 +131,80 @@ class UpdateProblemModuleStateError(Exception):
 
 
 def _get_current_task():
-    """Stub to make it easier to test without actually running Celery"""
+    """
+    Stub to make it easier to test without actually running Celery.
+
+    This is a wrapper around celery.current_task, which provides access
+    to the top of the stack of Celery's tasks.  When running tests, however,
+    it doesn't seem to work to mock current_task directly, so this wrapper
+    is used to provide a hook to mock in tests, while providing the real
+    `current_task` in production.
+    """
     return current_task
 
 
-def _perform_module_state_update(course_id, module_state_key, student_identifier, update_fcn, action_name, filter_fcn,
-                                 xmodule_instance_args):
+def run_main_task(entry_id, task_fcn, action_name):
+    """
+    Applies the `task_fcn` to the arguments defined in `entry_id` InstructorTask.
+
+    Arguments passed to `task_fcn` are:
+
+     `entry_id` : the primary key for the InstructorTask entry representing the task.
+     `course_id` : the id for the course.
+     `task_input` : dict containing task-specific arguments, JSON-decoded from InstructorTask's task_input.
+     `action_name` : past-tense verb to use for constructing status messages.
+
+    If no exceptions are raised, the `task_fcn` should return a dict containing
+    the task's result with the following keys:
+
+          'attempted': number of attempts made
+          'succeeded': number of attempts that "succeeded"
+          'skipped': number of attempts that "skipped"
+          'failed': number of attempts that "failed"
+          'total': number of possible subtasks to attempt
+          'action_name': user-visible verb to use in status messages.
+              Should be past-tense.  Pass-through of input `action_name`.
+          'duration_ms': how long the task has (or had) been running.
+
+    """
+
+    # get the InstructorTask to be updated.  If this fails, then let the exception return to Celery.
+    # There's no point in catching it here.
+    entry = InstructorTask.objects.get(pk=entry_id)
+
+    # get inputs to use in this task from the entry:
+    task_id = entry.task_id
+    course_id = entry.course_id
+    task_input = json.loads(entry.task_input)
+
+    # construct log message:
+    fmt = 'task "{task_id}": course "{course_id}" input "{task_input}"'
+    task_info_string = fmt.format(task_id=task_id, course_id=course_id, task_input=task_input)
+
+    TASK_LOG.info('Starting update (nothing %s yet): %s', action_name, task_info_string)
+
+    # Check that the task_id submitted in the InstructorTask matches the current task
+    # that is running.
+    request_task_id = _get_current_task().request.id
+    if task_id != request_task_id:
+        fmt = 'Requested task did not match actual task "{actual_id}": {task_info}'
+        message = fmt.format(actual_id=request_task_id, task_info=task_info_string)
+        TASK_LOG.error(message)
+        raise ValueError(message)
+
+    # Now do the work:
+    with dog_stats_api.timer('instructor_tasks.time.overall', tags=['action:{name}'.format(name=action_name)]):
+        task_progress = task_fcn(entry_id, course_id, task_input, action_name)
+
+    # Release any queries that the connection has been hanging onto:
+    reset_queries()
+
+    # log and exit, returning task_progress info as task result:
+    TASK_LOG.info('Finishing %s: final: %s', task_info_string, task_progress)
+    return task_progress
+
+
+def perform_module_state_update(update_fcn, filter_fcn, _entry_id, course_id, task_input, action_name):
     """
     Performs generic update by visiting StudentModule instances with the update_fcn provided.
 
@@ -71,8 +225,10 @@ def _perform_module_state_update(course_id, module_state_key, student_identifier
     The return value is a dict containing the task's results, with the following keys:
 
           'attempted': number of attempts made
-          'updated': number of attempts that "succeeded"
-          'total': number of possible subtasks to attempt
+          'succeeded': number of attempts that "succeeded"
+          'skipped': number of attempts that "skipped"
+          'failed': number of attempts that "failed"
+          'total': number of possible updates to attempt
           'action_name': user-visible verb to use in status messages.  Should be past-tense.
               Pass-through of input `action_name`.
           'duration_ms': how long the task has (or had) been running.
@@ -85,6 +241,9 @@ def _perform_module_state_update(course_id, module_state_key, student_identifier
     # get start time for task:
     start_time = time()
 
+    module_state_key = task_input.get('problem_url')
+    student_identifier = task_input.get('student')
+
     # find the problem descriptor:
     module_descriptor = modulestore().get_instance(course_id, module_state_key)
 
@@ -92,8 +251,8 @@ def _perform_module_state_update(course_id, module_state_key, student_identifier
     modules_to_update = StudentModule.objects.filter(course_id=course_id,
                                                      module_state_key=module_state_key)
 
-    # give the option of rescoring an individual student. If not specified,
-    # then rescores all students who have responded to a problem so far
+    # give the option of updating an individual student. If not specified,
+    # then updates all students who have responded to a problem so far
     student = None
     if student_identifier is not None:
         # if an identifier is supplied, then look for the student,
@@ -110,8 +269,10 @@ def _perform_module_state_update(course_id, module_state_key, student_identifier
         modules_to_update = filter_fcn(modules_to_update)
 
     # perform the main loop
-    num_updated = 0
     num_attempted = 0
+    num_succeeded = 0
+    num_skipped = 0
+    num_failed = 0
     num_total = modules_to_update.count()
 
     def get_task_progress():
@@ -119,7 +280,9 @@ def get_task_progress():
         current_time = time()
         progress = {'action_name': action_name,
                     'attempted': num_attempted,
-                    'updated': num_updated,
+                    'succeeded': num_succeeded,
+                    'skipped': num_skipped,
+                    'failed': num_failed,
                     'total': num_total,
                     'duration_ms': int((current_time - start_time) * 1000),
                     }
@@ -132,10 +295,17 @@ def get_task_progress():
         # There is no try here:  if there's an error, we let it throw, and the task will
         # be marked as FAILED, with a stack trace.
         with dog_stats_api.timer('instructor_tasks.module.time.step', tags=['action:{name}'.format(name=action_name)]):
-            if update_fcn(module_descriptor, module_to_update, xmodule_instance_args):
+            update_status = update_fcn(module_descriptor, module_to_update)
+            if update_status == UPDATE_STATUS_SUCCEEDED:
                 # If the update_fcn returns true, then it performed some kind of work.
                 # Logging of failures is left to the update_fcn itself.
-                num_updated += 1
+                num_succeeded += 1
+            elif update_status == UPDATE_STATUS_FAILED:
+                num_failed += 1
+            elif update_status == UPDATE_STATUS_SKIPPED:
+                num_skipped += 1
+            else:
+                raise UpdateProblemModuleStateError("Unexpected update_status returned: {}".format(update_status))
 
         # update task status:
         task_progress = get_task_progress()
@@ -144,101 +314,30 @@ def get_task_progress():
     return task_progress
 
 
-def update_problem_module_state(entry_id, update_fcn, action_name, filter_fcn,
-                                xmodule_instance_args):
-    """
-    Performs generic update by visiting StudentModule instances with the update_fcn provided.
-
-    The `entry_id` is the primary key for the InstructorTask entry representing the task.  This function
-    updates the entry on success and failure of the _perform_module_state_update function it
-    wraps.  It is setting the entry's value for task_state based on what Celery would set it to once
-    the task returns to Celery:  FAILURE if an exception is encountered, and SUCCESS if it returns normally.
-    Other arguments are pass-throughs to _perform_module_state_update, and documented there.
-
-    If no exceptions are raised, a dict containing the task's result is returned, with the following keys:
-
-          'attempted': number of attempts made
-          'updated': number of attempts that "succeeded"
-          'total': number of possible subtasks to attempt
-          'action_name': user-visible verb to use in status messages.  Should be past-tense.
-              Pass-through of input `action_name`.
-          'duration_ms': how long the task has (or had) been running.
-
-    Before returning, this is also JSON-serialized and stored in the task_output column of the InstructorTask entry.
+def _get_task_id_from_xmodule_args(xmodule_instance_args):
+    """Gets task_id from `xmodule_instance_args` dict, or returns default value if missing."""
+    return xmodule_instance_args.get('task_id', UNKNOWN_TASK_ID) if xmodule_instance_args is not None else UNKNOWN_TASK_ID
 
-    If an exception is raised internally, it is caught and recorded in the InstructorTask entry.
-    This is also a JSON-serialized dict, stored in the task_output column, containing the following keys:
 
-           'exception':  type of exception object
-           'message': error message from exception object
-           'traceback': traceback information (truncated if necessary)
+def _get_xqueue_callback_url_prefix(xmodule_instance_args):
+    """Gets prefix to use when constructing xqueue_callback_url."""
+    return xmodule_instance_args.get('xqueue_callback_url_prefix', '') if xmodule_instance_args is not None else ''
 
-    Once the exception is caught, it is raised again and allowed to pass up to the
-    task-running level, so that it can also set the failure modes and capture the error trace in the
-    result object that Celery creates.
 
+def _get_track_function_for_task(student, xmodule_instance_args=None, source_page='x_module_task'):
     """
+    Make a tracking function that logs what happened.
 
-    # get the InstructorTask to be updated.  If this fails, then let the exception return to Celery.
-    # There's no point in catching it here.
-    entry = InstructorTask.objects.get(pk=entry_id)
-
-    # get inputs to use in this task from the entry:
-    task_id = entry.task_id
-    course_id = entry.course_id
-    task_input = json.loads(entry.task_input)
-    module_state_key = task_input.get('problem_url')
-    student_ident = task_input['student'] if 'student' in task_input else None
-
-    fmt = 'Starting to update problem modules as task "{task_id}": course "{course_id}" problem "{state_key}": nothing {action} yet'
-    TASK_LOG.info(fmt.format(task_id=task_id, course_id=course_id, state_key=module_state_key, action=action_name))
-
-    # add task_id to xmodule_instance_args, so that it can be output with tracking info:
-    if xmodule_instance_args is not None:
-        xmodule_instance_args['task_id'] = task_id
-
-    # Now that we have an entry we can try to catch failures:
-    task_progress = None
-    try:
-        # Check that the task_id submitted in the InstructorTask matches the current task
-        # that is running.
-        request_task_id = _get_current_task().request.id
-        if task_id != request_task_id:
-            fmt = 'Requested task "{task_id}" did not match actual task "{actual_id}"'
-            message = fmt.format(task_id=task_id, course_id=course_id, state_key=module_state_key, actual_id=request_task_id)
-            TASK_LOG.error(message)
-            raise UpdateProblemModuleStateError(message)
-
-        # Now do the work:
-        with dog_stats_api.timer('instructor_tasks.module.time.overall', tags=['action:{name}'.format(name=action_name)]):
-            task_progress = _perform_module_state_update(course_id, module_state_key, student_ident, update_fcn,
-                                                         action_name, filter_fcn, xmodule_instance_args)
-        # If we get here, we assume we've succeeded, so update the InstructorTask entry in anticipation.
-        # But we do this within the try, in case creating the task_output causes an exception to be
-        # raised.
-        entry.task_output = InstructorTask.create_output_for_success(task_progress)
-        entry.task_state = SUCCESS
-        entry.save_now()
-
-    except Exception:
-        # try to write out the failure to the entry before failing
-        _, exception, traceback = exc_info()
-        traceback_string = format_exc(traceback) if traceback is not None else ''
-        TASK_LOG.warning("background task (%s) failed: %s %s", task_id, exception, traceback_string)
-        entry.task_output = InstructorTask.create_output_for_failure(exception, traceback_string)
-        entry.task_state = FAILURE
-        entry.save_now()
-        raise
-
-    # log and exit, returning task_progress info as task result:
-    fmt = 'Finishing task "{task_id}": course "{course_id}" problem "{state_key}": final: {progress}'
-    TASK_LOG.info(fmt.format(task_id=task_id, course_id=course_id, state_key=module_state_key, progress=task_progress))
-    return task_progress
-
+    For insertion into ModuleSystem, and used by CapaModule, which will
+    provide the event_type (as string) and event (as dict) as arguments.
+    The request_info and task_info (and page) are provided here.
+    """
+    # get request-related tracking information from args passthrough, and supplement with task-specific
+    # information:
+    request_info = xmodule_instance_args.get('request_info', {}) if xmodule_instance_args is not None else {}
+    task_info = {'student': student.username, 'task_id': _get_task_id_from_xmodule_args(xmodule_instance_args)}
 
-def _get_task_id_from_xmodule_args(xmodule_instance_args):
-    """Gets task_id from `xmodule_instance_args` dict, or returns default value if missing."""
-    return xmodule_instance_args.get('task_id', UNKNOWN_TASK_ID) if xmodule_instance_args is not None else UNKNOWN_TASK_ID
+    return lambda event_type, event: task_track(request_info, task_info, event_type, event, page=source_page)
 
 
 def _get_module_instance_for_task(course_id, student, module_descriptor, xmodule_instance_args=None,
@@ -277,7 +376,7 @@ def make_track_function():
 
 
 @transaction.autocommit
-def rescore_problem_module_state(module_descriptor, student_module, xmodule_instance_args=None):
+def rescore_problem_module_state(xmodule_instance_args, module_descriptor, student_module):
     '''
     Takes an XModule descriptor and a corresponding StudentModule object, and
     performs rescoring on the student's problem submission.
@@ -314,24 +413,26 @@ def rescore_problem_module_state(module_descriptor, student_module, xmodule_inst
         # don't consider these fatal, but false means that the individual call didn't complete:
         TASK_LOG.warning(u"error processing rescore call for course {course}, problem {loc} and student {student}: "
                          "unexpected response {msg}".format(msg=result, course=course_id, loc=module_state_key, student=student))
-        return False
+        return UPDATE_STATUS_FAILED
     elif result['success'] not in ['correct', 'incorrect']:
         TASK_LOG.warning(u"error processing rescore call for course {course}, problem {loc} and student {student}: "
                          "{msg}".format(msg=result['success'], course=course_id, loc=module_state_key, student=student))
-        return False
+        return UPDATE_STATUS_FAILED
     else:
         TASK_LOG.debug(u"successfully processed rescore call for course {course}, problem {loc} and student {student}: "
                        "{msg}".format(msg=result['success'], course=course_id, loc=module_state_key, student=student))
-        return True
+        return UPDATE_STATUS_SUCCEEDED
 
 
 @transaction.autocommit
-def reset_attempts_module_state(_module_descriptor, student_module, xmodule_instance_args=None):
+def reset_attempts_module_state(xmodule_instance_args, _module_descriptor, student_module):
     """
     Resets problem attempts to zero for specified `student_module`.
 
-    Always returns true, indicating success, if it doesn't raise an exception due to database error.
+    Returns a status of UPDATE_STATUS_SUCCEEDED if a problem has non-zero attempts
+    that are being reset, and UPDATE_STATUS_SKIPPED otherwise.
     """
+    update_status = UPDATE_STATUS_SKIPPED
     problem_state = json.loads(student_module.state) if student_module.state else {}
     if 'attempts' in problem_state:
         old_number_of_attempts = problem_state["attempts"]
@@ -342,26 +443,24 @@ def reset_attempts_module_state(_module_descriptor, student_module, xmodule_inst
             student_module.save()
             # get request-related tracking information from args passthrough,
             # and supplement with task-specific information:
-            request_info = xmodule_instance_args.get('request_info', {}) if xmodule_instance_args is not None else {}
-            task_info = {"student": student_module.student.username, "task_id": _get_task_id_from_xmodule_args(xmodule_instance_args)}
+            track_function = _get_track_function_for_task(student_module.student, xmodule_instance_args)
             event_info = {"old_attempts": old_number_of_attempts, "new_attempts": 0}
-            task_track(request_info, task_info, 'problem_reset_attempts', event_info, page='x_module_task')
+            track_function('problem_reset_attempts', event_info)
+            update_status = UPDATE_STATUS_SUCCEEDED
 
-    # consider the reset to be successful, even if no update was performed.  (It's just "optimized".)
-    return True
+    return update_status
 
 
 @transaction.autocommit
-def delete_problem_module_state(_module_descriptor, student_module, xmodule_instance_args=None):
+def delete_problem_module_state(xmodule_instance_args, _module_descriptor, student_module):
     """
     Delete the StudentModule entry.
 
-    Always returns true, indicating success, if it doesn't raise an exception due to database error.
+    Always returns UPDATE_STATUS_SUCCEEDED, indicating success, if it doesn't raise an exception due to database error.
     """
     student_module.delete()
     # get request-related tracking information from args passthrough,
     # and supplement with task-specific information:
-    request_info = xmodule_instance_args.get('request_info', {}) if xmodule_instance_args is not None else {}
-    task_info = {"student": student_module.student.username, "task_id": _get_task_id_from_xmodule_args(xmodule_instance_args)}
-    task_track(request_info, task_info, 'problem_delete_state', {}, page='x_module_task')
-    return True
+    track_function = _get_track_function_for_task(student_module.student, xmodule_instance_args)
+    track_function('problem_delete_state', {})
+    return UPDATE_STATUS_SUCCEEDED
diff --git a/lms/djangoapps/instructor_task/tests/test_api.py b/lms/djangoapps/instructor_task/tests/test_api.py
index 1e40c51c4bab..aa34e5187203 100644
--- a/lms/djangoapps/instructor_task/tests/test_api.py
+++ b/lms/djangoapps/instructor_task/tests/test_api.py
@@ -6,16 +6,21 @@
 
 from courseware.tests.factories import UserFactory
 
-from instructor_task.api import (get_running_instructor_tasks,
-                                 get_instructor_task_history,
-                                 submit_rescore_problem_for_all_students,
-                                 submit_rescore_problem_for_student,
-                                 submit_reset_problem_attempts_for_all_students,
-                                 submit_delete_problem_state_for_all_students)
+from bulk_email.models import CourseEmail, SEND_TO_ALL
+from instructor_task.api import (
+    get_running_instructor_tasks,
+    get_instructor_task_history,
+    submit_rescore_problem_for_all_students,
+    submit_rescore_problem_for_student,
+    submit_reset_problem_attempts_for_all_students,
+    submit_delete_problem_state_for_all_students,
+    submit_bulk_course_email,
+)
 
 from instructor_task.api_helper import AlreadyRunningError
 from instructor_task.models import InstructorTask, PROGRESS
 from instructor_task.tests.test_base import (InstructorTaskTestCase,
+                                             InstructorTaskCourseTestCase,
                                              InstructorTaskModuleTestCase,
                                              TEST_COURSE_ID)
 
@@ -42,12 +47,28 @@ def test_get_instructor_task_history(self):
             expected_ids.append(self._create_success_entry().task_id)
             expected_ids.append(self._create_progress_entry().task_id)
         task_ids = [instructor_task.task_id for instructor_task
-                    in get_instructor_task_history(TEST_COURSE_ID, self.problem_url)]
+                    in get_instructor_task_history(TEST_COURSE_ID, problem_url=self.problem_url)]
         self.assertEquals(set(task_ids), set(expected_ids))
+        # make the same call using explicit task_type:
+        task_ids = [instructor_task.task_id for instructor_task
+                    in get_instructor_task_history(
+                        TEST_COURSE_ID,
+                        problem_url=self.problem_url,
+                        task_type='rescore_problem'
+                    )]
+        self.assertEquals(set(task_ids), set(expected_ids))
+        # make the same call using a non-existent task_type:
+        task_ids = [instructor_task.task_id for instructor_task
+                    in get_instructor_task_history(
+                        TEST_COURSE_ID,
+                        problem_url=self.problem_url,
+                        task_type='dummy_type'
+                    )]
+        self.assertEquals(set(task_ids), set())
 
 
-class InstructorTaskSubmitTest(InstructorTaskModuleTestCase):
-    """Tests API methods that involve the submission of background tasks."""
+class InstructorTaskModuleSubmitTest(InstructorTaskModuleTestCase):
+    """Tests API methods that involve the submission of module-based background tasks."""
 
     def setUp(self):
         self.initialize_course()
@@ -136,3 +157,29 @@ def test_submit_reset_all(self):
 
     def test_submit_delete_all(self):
         self._test_submit_task(submit_delete_problem_state_for_all_students)
+
+
+class InstructorTaskCourseSubmitTest(InstructorTaskCourseTestCase):
+    """Tests API methods that involve the submission of course-based background tasks."""
+
+    def setUp(self):
+        self.initialize_course()
+        self.student = UserFactory.create(username="student", email="student@edx.org")
+        self.instructor = UserFactory.create(username="instructor", email="instructor@edx.org")
+
+    def _define_course_email(self):
+        """Create CourseEmail object for testing."""
+        course_email = CourseEmail.create(self.course.id, self.instructor, SEND_TO_ALL, "Test Subject", "<p>This is a test message</p>")
+        return course_email.id  # pylint: disable=E1101
+
+    def test_submit_bulk_email_all(self):
+        email_id = self._define_course_email()
+        instructor_task = submit_bulk_course_email(self.create_task_request(self.instructor), self.course.id, email_id)
+
+        # test resubmitting, by updating the existing record:
+        instructor_task = InstructorTask.objects.get(id=instructor_task.id)  # pylint: disable=E1101
+        instructor_task.task_state = PROGRESS
+        instructor_task.save()
+
+        with self.assertRaises(AlreadyRunningError):
+            instructor_task = submit_bulk_course_email(self.create_task_request(self.instructor), self.course.id, email_id)
diff --git a/lms/djangoapps/instructor_task/tests/test_base.py b/lms/djangoapps/instructor_task/tests/test_base.py
index 2c1fe02bd8a0..e0abfdf51f03 100644
--- a/lms/djangoapps/instructor_task/tests/test_base.py
+++ b/lms/djangoapps/instructor_task/tests/test_base.py
@@ -88,7 +88,7 @@ def _create_success_entry(self, student=None):
     def _create_progress_entry(self, student=None, task_state=PROGRESS):
         """Creates a InstructorTask entry representing a task in progress."""
         progress = {'attempted': 3,
-                    'updated': 2,
+                    'succeeded': 2,
                     'total': 5,
                     'action_name': 'rescored',
                     }
@@ -96,10 +96,10 @@ def _create_progress_entry(self, student=None, task_state=PROGRESS):
 
 
 @override_settings(MODULESTORE=TEST_DATA_MIXED_MODULESTORE)
-class InstructorTaskModuleTestCase(LoginEnrollmentTestCase, ModuleStoreTestCase):
+class InstructorTaskCourseTestCase(LoginEnrollmentTestCase, ModuleStoreTestCase):
     """
     Base test class for InstructorTask-related tests that require
-    the setup of a course and problem in order to access StudentModule state.
+    the setup of a course.
     """
     course = None
     current_user = None
@@ -120,6 +120,7 @@ def initialize_course(self):
         # add a sequence to the course to which the problems can be added
         self.problem_section = ItemFactory.create(parent_location=chapter.location,
                                                   category='sequential',
+                                                  metadata={'graded': True, 'format': 'Homework'},
                                                   display_name=TEST_SECTION_NAME)
 
     @staticmethod
@@ -130,12 +131,12 @@ def get_user_email(username):
     def login_username(self, username):
         """Login the user, given the `username`."""
         if self.current_user != username:
-            self.login(InstructorTaskModuleTestCase.get_user_email(username), "test")
+            self.login(InstructorTaskCourseTestCase.get_user_email(username), "test")
             self.current_user = username
 
     def _create_user(self, username, is_staff=False):
         """Creates a user and enrolls them in the test course."""
-        email = InstructorTaskModuleTestCase.get_user_email(username)
+        email = InstructorTaskCourseTestCase.get_user_email(username)
         thisuser = UserFactory.create(username=username, email=email, is_staff=is_staff)
         CourseEnrollmentFactory.create(user=thisuser, course_id=self.course.id)
         return thisuser
@@ -148,6 +149,31 @@ def create_student(self, username):
         """Creates a student for the test course."""
         return self._create_user(username, is_staff=False)
 
+    @staticmethod
+    def get_task_status(task_id):
+        """Use api method to fetch task status, using mock request."""
+        mock_request = Mock()
+        mock_request.REQUEST = {'task_id': task_id}
+        response = instructor_task_status(mock_request)
+        status = json.loads(response.content)
+        return status
+
+    def create_task_request(self, requester_username):
+        """Generate request that can be used for submitting tasks"""
+        request = Mock()
+        request.user = User.objects.get(username=requester_username)
+        request.get_host = Mock(return_value="testhost")
+        request.META = {'REMOTE_ADDR': '0:0:0:0', 'SERVER_NAME': 'testhost'}
+        request.is_secure = Mock(return_value=False)
+        return request
+
+
+@override_settings(MODULESTORE=TEST_DATA_MIXED_MODULESTORE)
+class InstructorTaskModuleTestCase(InstructorTaskCourseTestCase):
+    """
+    Base test class for InstructorTask-related tests that require
+    the setup of a course and problem in order to access StudentModule state.
+    """
     @staticmethod
     def problem_location(problem_url_name):
         """
@@ -191,21 +217,3 @@ def get_student_module(self, username, descriptor):
                                          module_type=descriptor.location.category,
                                          module_state_key=descriptor.location.url(),
                                          )
-
-    @staticmethod
-    def get_task_status(task_id):
-        """Use api method to fetch task status, using mock request."""
-        mock_request = Mock()
-        mock_request.REQUEST = {'task_id': task_id}
-        response = instructor_task_status(mock_request)
-        status = json.loads(response.content)
-        return status
-
-    def create_task_request(self, requester_username):
-        """Generate request that can be used for submitting tasks"""
-        request = Mock()
-        request.user = User.objects.get(username=requester_username)
-        request.get_host = Mock(return_value="testhost")
-        request.META = {'REMOTE_ADDR': '0:0:0:0', 'SERVER_NAME': 'testhost'}
-        request.is_secure = Mock(return_value=False)
-        return request
diff --git a/lms/djangoapps/instructor_task/tests/test_integration.py b/lms/djangoapps/instructor_task/tests/test_integration.py
index fb8cd4416917..b36467c16fb0 100644
--- a/lms/djangoapps/instructor_task/tests/test_integration.py
+++ b/lms/djangoapps/instructor_task/tests/test_integration.py
@@ -227,7 +227,7 @@ def test_rescoring_bad_unicode_input(self):
         self.assertEqual(task_input['problem_url'], InstructorTaskModuleTestCase.problem_location(problem_url_name))
         status = json.loads(instructor_task.task_output)
         self.assertEqual(status['attempted'], 1)
-        self.assertEqual(status['updated'], 0)
+        self.assertEqual(status['succeeded'], 0)
         self.assertEqual(status['total'], 1)
 
     def define_code_response_problem(self, problem_url_name):
diff --git a/lms/djangoapps/instructor_task/tests/test_tasks.py b/lms/djangoapps/instructor_task/tests/test_tasks.py
index 090c1147209b..5aa5dbcb80f6 100644
--- a/lms/djangoapps/instructor_task/tests/test_tasks.py
+++ b/lms/djangoapps/instructor_task/tests/test_tasks.py
@@ -7,24 +7,22 @@
 """
 import json
 from uuid import uuid4
-from unittest import skip
 
-from mock import Mock, patch
+from mock import Mock, MagicMock, patch
 
 from celery.states import SUCCESS, FAILURE
 
 from xmodule.modulestore.exceptions import ItemNotFoundError
 
-from courseware.model_data import StudentModule
+from courseware.models import StudentModule
 from courseware.tests.factories import StudentModuleFactory
-from student.tests.factories import UserFactory
+from student.tests.factories import UserFactory, CourseEnrollmentFactory
 
 from instructor_task.models import InstructorTask
 from instructor_task.tests.test_base import InstructorTaskModuleTestCase
 from instructor_task.tests.factories import InstructorTaskFactory
 from instructor_task.tasks import rescore_problem, reset_problem_attempts, delete_problem_state
-from instructor_task.tasks_helper import UpdateProblemModuleStateError, update_problem_module_state
-
+from instructor_task.tasks_helper import UpdateProblemModuleStateError
 
 PROBLEM_URL_NAME = "test_urlname"
 
@@ -34,20 +32,24 @@ class TestTaskFailure(Exception):
 
 
 class TestInstructorTasks(InstructorTaskModuleTestCase):
+
     def setUp(self):
         super(InstructorTaskModuleTestCase, self).setUp()
         self.initialize_course()
         self.instructor = self.create_instructor('instructor')
         self.problem_url = InstructorTaskModuleTestCase.problem_location(PROBLEM_URL_NAME)
 
-    def _create_input_entry(self, student_ident=None):
+    def _create_input_entry(self, student_ident=None, use_problem_url=True, course_id=None):
         """Creates a InstructorTask entry for testing."""
         task_id = str(uuid4())
-        task_input = {'problem_url': self.problem_url}
+        task_input = {}
+        if use_problem_url:
+            task_input['problem_url'] = self.problem_url
         if student_ident is not None:
             task_input['student'] = student_ident
 
-        instructor_task = InstructorTaskFactory.create(course_id=self.course.id,
+        course_id = course_id or self.course.id
+        instructor_task = InstructorTaskFactory.create(course_id=course_id,
                                                        requester=self.instructor,
                                                        task_input=json.dumps(task_input),
                                                        task_key='dummy value',
@@ -62,7 +64,7 @@ def _get_xmodule_instance_args(self):
                 'request_info': {},
                 }
 
-    def _run_task_with_mock_celery(self, task_function, entry_id, task_id, expected_failure_message=None):
+    def _run_task_with_mock_celery(self, task_class, entry_id, task_id, expected_failure_message=None):
         """Submit a task and mock how celery provides a current_task."""
         self.current_task = Mock()
         self.current_task.request = Mock()
@@ -70,70 +72,52 @@ def _run_task_with_mock_celery(self, task_function, entry_id, task_id, expected_
         self.current_task.update_state = Mock()
         if expected_failure_message is not None:
             self.current_task.update_state.side_effect = TestTaskFailure(expected_failure_message)
+        task_args = [entry_id, self._get_xmodule_instance_args()]
+
         with patch('instructor_task.tasks_helper._get_current_task') as mock_get_task:
             mock_get_task.return_value = self.current_task
-            return task_function(entry_id, self._get_xmodule_instance_args())
+            return task_class.apply(task_args, task_id=task_id).get()
 
-    def _test_missing_current_task(self, task_function):
-        """Check that a task_function fails when celery doesn't provide a current_task."""
+    def _test_missing_current_task(self, task_class):
+        """Check that a task_class fails when celery doesn't provide a current_task."""
         task_entry = self._create_input_entry()
-        with self.assertRaises(UpdateProblemModuleStateError):
-            task_function(task_entry.id, self._get_xmodule_instance_args())
-
-    def test_rescore_missing_current_task(self):
-        self._test_missing_current_task(rescore_problem)
-
-    def test_reset_missing_current_task(self):
-        self._test_missing_current_task(reset_problem_attempts)
+        with self.assertRaises(ValueError):
+            task_class(task_entry.id, self._get_xmodule_instance_args())
 
-    def test_delete_missing_current_task(self):
-        self._test_missing_current_task(delete_problem_state)
+    def _test_undefined_course(self, task_class):
+        """Run with celery, but with no course defined."""
+        task_entry = self._create_input_entry(course_id="bogus/course/id")
+        with self.assertRaises(ItemNotFoundError):
+            self._run_task_with_mock_celery(task_class, task_entry.id, task_entry.task_id)
 
-    def _test_undefined_problem(self, task_function):
+    def _test_undefined_problem(self, task_class):
         """Run with celery, but no problem defined."""
         task_entry = self._create_input_entry()
         with self.assertRaises(ItemNotFoundError):
-            self._run_task_with_mock_celery(task_function, task_entry.id, task_entry.task_id)
-
-    def test_rescore_undefined_problem(self):
-        self._test_undefined_problem(rescore_problem)
-
-    def test_reset_undefined_problem(self):
-        self._test_undefined_problem(reset_problem_attempts)
-
-    def test_delete_undefined_problem(self):
-        self._test_undefined_problem(delete_problem_state)
+            self._run_task_with_mock_celery(task_class, task_entry.id, task_entry.task_id)
 
-    def _test_run_with_task(self, task_function, action_name, expected_num_updated):
+    def _test_run_with_task(self, task_class, action_name, expected_num_succeeded, expected_num_skipped=0):
         """Run a task and check the number of StudentModules processed."""
         task_entry = self._create_input_entry()
-        status = self._run_task_with_mock_celery(task_function, task_entry.id, task_entry.task_id)
+        status = self._run_task_with_mock_celery(task_class, task_entry.id, task_entry.task_id)
         # check return value
-        self.assertEquals(status.get('attempted'), expected_num_updated)
-        self.assertEquals(status.get('updated'), expected_num_updated)
-        self.assertEquals(status.get('total'), expected_num_updated)
+        self.assertEquals(status.get('attempted'), expected_num_succeeded + expected_num_skipped)
+        self.assertEquals(status.get('succeeded'), expected_num_succeeded)
+        self.assertEquals(status.get('skipped'), expected_num_skipped)
+        self.assertEquals(status.get('total'), expected_num_succeeded + expected_num_skipped)
         self.assertEquals(status.get('action_name'), action_name)
-        self.assertGreater('duration_ms', 0)
+        self.assertGreater(status.get('duration_ms'), 0)
         # compare with entry in table:
         entry = InstructorTask.objects.get(id=task_entry.id)
         self.assertEquals(json.loads(entry.task_output), status)
         self.assertEquals(entry.task_state, SUCCESS)
 
-    def _test_run_with_no_state(self, task_function, action_name):
+    def _test_run_with_no_state(self, task_class, action_name):
         """Run with no StudentModules defined for the current problem."""
         self.define_option_problem(PROBLEM_URL_NAME)
-        self._test_run_with_task(task_function, action_name, 0)
-
-    def test_rescore_with_no_state(self):
-        self._test_run_with_no_state(rescore_problem, 'rescored')
-
-    def test_reset_with_no_state(self):
-        self._test_run_with_no_state(reset_problem_attempts, 'reset')
-
-    def test_delete_with_no_state(self):
-        self._test_run_with_no_state(delete_problem_state, 'deleted')
+        self._test_run_with_task(task_class, action_name, 0)
 
-    def _create_students_with_state(self, num_students, state=None):
+    def _create_students_with_state(self, num_students, state=None, grade=0, max_grade=1):
         """Create students, a problem, and StudentModule objects for testing"""
         self.define_option_problem(PROBLEM_URL_NAME)
         students = [
@@ -141,9 +125,12 @@ def _create_students_with_state(self, num_students, state=None):
             for i in xrange(num_students)
         ]
         for student in students:
+            CourseEnrollmentFactory.create(course_id=self.course.id, user=student)
             StudentModuleFactory.create(course_id=self.course.id,
                                         module_state_key=self.problem_url,
                                         student=student,
+                                        grade=grade,
+                                        max_grade=max_grade,
                                         state=state)
         return students
 
@@ -156,90 +143,12 @@ def _assert_num_attempts(self, students, num_attempts):
             state = json.loads(module.state)
             self.assertEquals(state['attempts'], num_attempts)
 
-    def test_reset_with_some_state(self):
-        initial_attempts = 3
-        input_state = json.dumps({'attempts': initial_attempts})
-        num_students = 10
-        students = self._create_students_with_state(num_students, input_state)
-        # check that entries were set correctly
-        self._assert_num_attempts(students, initial_attempts)
-        # run the task
-        self._test_run_with_task(reset_problem_attempts, 'reset', num_students)
-        # check that entries were reset
-        self._assert_num_attempts(students, 0)
-
-    def test_delete_with_some_state(self):
-        # This will create StudentModule entries -- we don't have to worry about
-        # the state inside them.
-        num_students = 10
-        students = self._create_students_with_state(num_students)
-        # check that entries were created correctly
-        for student in students:
-            StudentModule.objects.get(course_id=self.course.id,
-                                      student=student,
-                                      module_state_key=self.problem_url)
-        self._test_run_with_task(delete_problem_state, 'deleted', num_students)
-        # confirm that no state can be found anymore:
-        for student in students:
-            with self.assertRaises(StudentModule.DoesNotExist):
-                StudentModule.objects.get(course_id=self.course.id,
-                                          student=student,
-                                          module_state_key=self.problem_url)
-
-    def _test_reset_with_student(self, use_email):
-        """Run a reset task for one student, with several StudentModules for the problem defined."""
-        num_students = 10
-        initial_attempts = 3
-        input_state = json.dumps({'attempts': initial_attempts})
-        students = self._create_students_with_state(num_students, input_state)
-        # check that entries were set correctly
-        for student in students:
-            module = StudentModule.objects.get(course_id=self.course.id,
-                                               student=student,
-                                               module_state_key=self.problem_url)
-            state = json.loads(module.state)
-            self.assertEquals(state['attempts'], initial_attempts)
-
-        if use_email:
-            student_ident = students[3].email
-        else:
-            student_ident = students[3].username
-        task_entry = self._create_input_entry(student_ident)
-
-        status = self._run_task_with_mock_celery(reset_problem_attempts, task_entry.id, task_entry.task_id)
-        # check return value
-        self.assertEquals(status.get('attempted'), 1)
-        self.assertEquals(status.get('updated'), 1)
-        self.assertEquals(status.get('total'), 1)
-        self.assertEquals(status.get('action_name'), 'reset')
-        self.assertGreater('duration_ms', 0)
-        # compare with entry in table:
-        entry = InstructorTask.objects.get(id=task_entry.id)
-        self.assertEquals(json.loads(entry.task_output), status)
-        self.assertEquals(entry.task_state, SUCCESS)
-        # check that the correct entry was reset
-        for index, student in enumerate(students):
-            module = StudentModule.objects.get(course_id=self.course.id,
-                                               student=student,
-                                               module_state_key=self.problem_url)
-            state = json.loads(module.state)
-            if index == 3:
-                self.assertEquals(state['attempts'], 0)
-            else:
-                self.assertEquals(state['attempts'], initial_attempts)
-
-    def test_reset_with_student_username(self):
-        self._test_reset_with_student(False)
-
-    def test_reset_with_student_email(self):
-        self._test_reset_with_student(True)
-
-    def _test_run_with_failure(self, task_function, expected_message):
-        """Run a task and trigger an artificial failure with give message."""
+    def _test_run_with_failure(self, task_class, expected_message):
+        """Run a task and trigger an artificial failure with the given message."""
         task_entry = self._create_input_entry()
         self.define_option_problem(PROBLEM_URL_NAME)
         with self.assertRaises(TestTaskFailure):
-            self._run_task_with_mock_celery(task_function, task_entry.id, task_entry.task_id, expected_message)
+            self._run_task_with_mock_celery(task_class, task_entry.id, task_entry.task_id, expected_message)
         # compare with entry in table:
         entry = InstructorTask.objects.get(id=task_entry.id)
         self.assertEquals(entry.task_state, FAILURE)
@@ -247,16 +156,7 @@ def _test_run_with_failure(self, task_function, expected_message):
         self.assertEquals(output['exception'], 'TestTaskFailure')
         self.assertEquals(output['message'], expected_message)
 
-    def test_rescore_with_failure(self):
-        self._test_run_with_failure(rescore_problem, 'We expected this to fail')
-
-    def test_reset_with_failure(self):
-        self._test_run_with_failure(reset_problem_attempts, 'We expected this to fail')
-
-    def test_delete_with_failure(self):
-        self._test_run_with_failure(delete_problem_state, 'We expected this to fail')
-
-    def _test_run_with_long_error_msg(self, task_function):
+    def _test_run_with_long_error_msg(self, task_class):
         """
         Run with an error message that is so long it will require
         truncation (as well as the jettisoning of the traceback).
@@ -265,7 +165,7 @@ def _test_run_with_long_error_msg(self, task_function):
         self.define_option_problem(PROBLEM_URL_NAME)
         expected_message = "x" * 1500
         with self.assertRaises(TestTaskFailure):
-            self._run_task_with_mock_celery(task_function, task_entry.id, task_entry.task_id, expected_message)
+            self._run_task_with_mock_celery(task_class, task_entry.id, task_entry.task_id, expected_message)
         # compare with entry in table:
         entry = InstructorTask.objects.get(id=task_entry.id)
         self.assertEquals(entry.task_state, FAILURE)
@@ -275,16 +175,7 @@ def _test_run_with_long_error_msg(self, task_function):
         self.assertEquals(output['message'], expected_message[:len(output['message']) - 3] + "...")
         self.assertTrue('traceback' not in output)
 
-    def test_rescore_with_long_error_msg(self):
-        self._test_run_with_long_error_msg(rescore_problem)
-
-    def test_reset_with_long_error_msg(self):
-        self._test_run_with_long_error_msg(reset_problem_attempts)
-
-    def test_delete_with_long_error_msg(self):
-        self._test_run_with_long_error_msg(delete_problem_state)
-
-    def _test_run_with_short_error_msg(self, task_function):
+    def _test_run_with_short_error_msg(self, task_class):
         """
         Run with an error message that is short enough to fit
         in the output, but long enough that the traceback won't.
@@ -294,7 +185,7 @@ def _test_run_with_short_error_msg(self, task_function):
         self.define_option_problem(PROBLEM_URL_NAME)
         expected_message = "x" * 900
         with self.assertRaises(TestTaskFailure):
-            self._run_task_with_mock_celery(task_function, task_entry.id, task_entry.task_id, expected_message)
+            self._run_task_with_mock_celery(task_class, task_entry.id, task_entry.task_id, expected_message)
         # compare with entry in table:
         entry = InstructorTask.objects.get(id=task_entry.id)
         self.assertEquals(entry.task_state, FAILURE)
@@ -304,48 +195,42 @@ def _test_run_with_short_error_msg(self, task_function):
         self.assertEquals(output['message'], expected_message)
         self.assertEquals(output['traceback'][-3:], "...")
 
-    def test_rescore_with_short_error_msg(self):
-        self._test_run_with_short_error_msg(rescore_problem)
 
-    def test_reset_with_short_error_msg(self):
-        self._test_run_with_short_error_msg(reset_problem_attempts)
+class TestRescoreInstructorTask(TestInstructorTasks):
+    """Tests problem-rescoring instructor task."""
 
-    def test_delete_with_short_error_msg(self):
-        self._test_run_with_short_error_msg(delete_problem_state)
+    def test_rescore_missing_current_task(self):
+        self._test_missing_current_task(rescore_problem)
 
-    def test_successful_result_too_long(self):
-        # while we don't expect the existing tasks to generate output that is too
-        # long, we can test the framework will handle such an occurrence.
-        task_entry = self._create_input_entry()
-        self.define_option_problem(PROBLEM_URL_NAME)
-        action_name = 'x' * 1000
-        update_fcn = lambda(_module_descriptor, _student_module, _xmodule_instance_args): True
-        task_function = (lambda entry_id, xmodule_instance_args:
-                         update_problem_module_state(entry_id,
-                                                     update_fcn, action_name, filter_fcn=None,
-                                                     xmodule_instance_args=None))
+    def test_rescore_undefined_course(self):
+        self._test_undefined_course(rescore_problem)
 
-        with self.assertRaises(ValueError):
-            self._run_task_with_mock_celery(task_function, task_entry.id, task_entry.task_id)
-        # compare with entry in table:
-        entry = InstructorTask.objects.get(id=task_entry.id)
-        self.assertEquals(entry.task_state, FAILURE)
-        self.assertGreater(1023, len(entry.task_output))
-        output = json.loads(entry.task_output)
-        self.assertEquals(output['exception'], 'ValueError')
-        self.assertTrue("Length of task output is too long" in output['message'])
-        self.assertTrue('traceback' not in output)
+    def test_rescore_undefined_problem(self):
+        self._test_undefined_problem(rescore_problem)
+
+    def test_rescore_with_no_state(self):
+        self._test_run_with_no_state(rescore_problem, 'rescored')
+
+    def test_rescore_with_failure(self):
+        self._test_run_with_failure(rescore_problem, 'We expected this to fail')
+
+    def test_rescore_with_long_error_msg(self):
+        self._test_run_with_long_error_msg(rescore_problem)
+
+    def test_rescore_with_short_error_msg(self):
+        self._test_run_with_short_error_msg(rescore_problem)
 
-    @skip
     def test_rescoring_unrescorable(self):
-        # TODO: this test needs to have Mako templates initialized
-        # to make sure that the creation of an XModule works.
         input_state = json.dumps({'done': True})
         num_students = 1
         self._create_students_with_state(num_students, input_state)
         task_entry = self._create_input_entry()
-        with self.assertRaises(UpdateProblemModuleStateError):
-            self._run_task_with_mock_celery(rescore_problem, task_entry.id, task_entry.task_id)
+        mock_instance = MagicMock()
+        del mock_instance.rescore_problem
+        with patch('instructor_task.tasks_helper.get_module_for_descriptor_internal') as mock_get_module:
+            mock_get_module.return_value = mock_instance
+            with self.assertRaises(UpdateProblemModuleStateError):
+                self._run_task_with_mock_celery(rescore_problem, task_entry.id, task_entry.task_id)
         # check values stored in table:
         entry = InstructorTask.objects.get(id=task_entry.id)
         output = json.loads(entry.task_output)
@@ -353,25 +238,202 @@ def test_rescoring_unrescorable(self):
         self.assertEquals(output['message'], "Specified problem does not support rescoring.")
         self.assertGreater(len(output['traceback']), 0)
 
-    @skip
     def test_rescoring_success(self):
-        # TODO: this test needs to have Mako templates initialized
-        # to make sure that the creation of an XModule works.
         input_state = json.dumps({'done': True})
         num_students = 10
         self._create_students_with_state(num_students, input_state)
         task_entry = self._create_input_entry()
         mock_instance = Mock()
-        mock_instance.rescore_problem = Mock({'success': 'correct'})
-        # TODO: figure out why this mock is not working....
-        with patch('courseware.module_render.get_module_for_descriptor_internal') as mock_get_module:
+        mock_instance.rescore_problem = Mock(return_value={'success': 'correct'})
+        with patch('instructor_task.tasks_helper.get_module_for_descriptor_internal') as mock_get_module:
+            mock_get_module.return_value = mock_instance
+            self._run_task_with_mock_celery(rescore_problem, task_entry.id, task_entry.task_id)
+        # check return value
+        entry = InstructorTask.objects.get(id=task_entry.id)
+        output = json.loads(entry.task_output)
+        self.assertEquals(output.get('attempted'), num_students)
+        self.assertEquals(output.get('succeeded'), num_students)
+        self.assertEquals(output.get('total'), num_students)
+        self.assertEquals(output.get('action_name'), 'rescored')
+        self.assertGreater(output.get('duration_ms'), 0)
+
+    def test_rescoring_bad_result(self):
+        # Confirm that rescoring does not succeed if "success" key is not an expected value.
+        input_state = json.dumps({'done': True})
+        num_students = 10
+        self._create_students_with_state(num_students, input_state)
+        task_entry = self._create_input_entry()
+        mock_instance = Mock()
+        mock_instance.rescore_problem = Mock(return_value={'success': 'bogus'})
+        with patch('instructor_task.tasks_helper.get_module_for_descriptor_internal') as mock_get_module:
+            mock_get_module.return_value = mock_instance
+            self._run_task_with_mock_celery(rescore_problem, task_entry.id, task_entry.task_id)
+        # check return value
+        entry = InstructorTask.objects.get(id=task_entry.id)
+        output = json.loads(entry.task_output)
+        self.assertEquals(output.get('attempted'), num_students)
+        self.assertEquals(output.get('succeeded'), 0)
+        self.assertEquals(output.get('total'), num_students)
+        self.assertEquals(output.get('action_name'), 'rescored')
+        self.assertGreater(output.get('duration_ms'), 0)
+
+    def test_rescoring_missing_result(self):
+        # Confirm that rescoring does not succeed if "success" key is not returned.
+        input_state = json.dumps({'done': True})
+        num_students = 10
+        self._create_students_with_state(num_students, input_state)
+        task_entry = self._create_input_entry()
+        mock_instance = Mock()
+        mock_instance.rescore_problem = Mock(return_value={'bogus': 'value'})
+        with patch('instructor_task.tasks_helper.get_module_for_descriptor_internal') as mock_get_module:
             mock_get_module.return_value = mock_instance
             self._run_task_with_mock_celery(rescore_problem, task_entry.id, task_entry.task_id)
         # check return value
         entry = InstructorTask.objects.get(id=task_entry.id)
         output = json.loads(entry.task_output)
         self.assertEquals(output.get('attempted'), num_students)
-        self.assertEquals(output.get('updated'), num_students)
+        self.assertEquals(output.get('succeeded'), 0)
         self.assertEquals(output.get('total'), num_students)
         self.assertEquals(output.get('action_name'), 'rescored')
-        self.assertGreater('duration_ms', 0)
+        self.assertGreater(output.get('duration_ms'), 0)
+
+
+class TestResetAttemptsInstructorTask(TestInstructorTasks):
+    """Tests instructor task that resets problem attempts."""
+
+    def test_reset_missing_current_task(self):
+        self._test_missing_current_task(reset_problem_attempts)
+
+    def test_reset_undefined_course(self):
+        self._test_undefined_course(reset_problem_attempts)
+
+    def test_reset_undefined_problem(self):
+        self._test_undefined_problem(reset_problem_attempts)
+
+    def test_reset_with_no_state(self):
+        self._test_run_with_no_state(reset_problem_attempts, 'reset')
+
+    def test_reset_with_failure(self):
+        self._test_run_with_failure(reset_problem_attempts, 'We expected this to fail')
+
+    def test_reset_with_long_error_msg(self):
+        self._test_run_with_long_error_msg(reset_problem_attempts)
+
+    def test_reset_with_short_error_msg(self):
+        self._test_run_with_short_error_msg(reset_problem_attempts)
+
+    def test_reset_with_some_state(self):
+        initial_attempts = 3
+        input_state = json.dumps({'attempts': initial_attempts})
+        num_students = 10
+        students = self._create_students_with_state(num_students, input_state)
+        # check that entries were set correctly
+        self._assert_num_attempts(students, initial_attempts)
+        # run the task
+        self._test_run_with_task(reset_problem_attempts, 'reset', num_students)
+        # check that entries were reset
+        self._assert_num_attempts(students, 0)
+
+    def test_reset_with_zero_attempts(self):
+        initial_attempts = 0
+        input_state = json.dumps({'attempts': initial_attempts})
+        num_students = 10
+        students = self._create_students_with_state(num_students, input_state)
+        # check that entries were set correctly
+        self._assert_num_attempts(students, initial_attempts)
+        # run the task
+        self._test_run_with_task(reset_problem_attempts, 'reset', 0, expected_num_skipped=num_students)
+        # check that entries were reset
+        self._assert_num_attempts(students, 0)
+
+    def _test_reset_with_student(self, use_email):
+        """Run a reset task for one student, with several StudentModules for the problem defined."""
+        num_students = 10
+        initial_attempts = 3
+        input_state = json.dumps({'attempts': initial_attempts})
+        students = self._create_students_with_state(num_students, input_state)
+        # check that entries were set correctly
+        for student in students:
+            module = StudentModule.objects.get(course_id=self.course.id,
+                                               student=student,
+                                               module_state_key=self.problem_url)
+            state = json.loads(module.state)
+            self.assertEquals(state['attempts'], initial_attempts)
+
+        if use_email:
+            student_ident = students[3].email
+        else:
+            student_ident = students[3].username
+        task_entry = self._create_input_entry(student_ident)
+
+        status = self._run_task_with_mock_celery(reset_problem_attempts, task_entry.id, task_entry.task_id)
+        # check return value
+        self.assertEquals(status.get('attempted'), 1)
+        self.assertEquals(status.get('succeeded'), 1)
+        self.assertEquals(status.get('total'), 1)
+        self.assertEquals(status.get('action_name'), 'reset')
+        self.assertGreater(status.get('duration_ms'), 0)
+
+        # compare with entry in table:
+        entry = InstructorTask.objects.get(id=task_entry.id)
+        self.assertEquals(json.loads(entry.task_output), status)
+        self.assertEquals(entry.task_state, SUCCESS)
+        # check that the correct entry was reset
+        for index, student in enumerate(students):
+            module = StudentModule.objects.get(course_id=self.course.id,
+                                               student=student,
+                                               module_state_key=self.problem_url)
+            state = json.loads(module.state)
+            if index == 3:
+                self.assertEquals(state['attempts'], 0)
+            else:
+                self.assertEquals(state['attempts'], initial_attempts)
+
+    def test_reset_with_student_username(self):
+        self._test_reset_with_student(False)
+
+    def test_reset_with_student_email(self):
+        self._test_reset_with_student(True)
+
+
+class TestDeleteStateInstructorTask(TestInstructorTasks):
+    """Tests instructor task that deletes problem state."""
+
+    def test_delete_missing_current_task(self):
+        self._test_missing_current_task(delete_problem_state)
+
+    def test_delete_undefined_course(self):
+        self._test_undefined_course(delete_problem_state)
+
+    def test_delete_undefined_problem(self):
+        self._test_undefined_problem(delete_problem_state)
+
+    def test_delete_with_no_state(self):
+        self._test_run_with_no_state(delete_problem_state, 'deleted')
+
+    def test_delete_with_failure(self):
+        self._test_run_with_failure(delete_problem_state, 'We expected this to fail')
+
+    def test_delete_with_long_error_msg(self):
+        self._test_run_with_long_error_msg(delete_problem_state)
+
+    def test_delete_with_short_error_msg(self):
+        self._test_run_with_short_error_msg(delete_problem_state)
+
+    def test_delete_with_some_state(self):
+        # This will create StudentModule entries -- we don't have to worry about
+        # the state inside them.
+        num_students = 10
+        students = self._create_students_with_state(num_students)
+        # check that entries were created correctly
+        for student in students:
+            StudentModule.objects.get(course_id=self.course.id,
+                                      student=student,
+                                      module_state_key=self.problem_url)
+        self._test_run_with_task(delete_problem_state, 'deleted', num_students)
+        # confirm that no state can be found anymore:
+        for student in students:
+            with self.assertRaises(StudentModule.DoesNotExist):
+                StudentModule.objects.get(course_id=self.course.id,
+                                          student=student,
+                                          module_state_key=self.problem_url)
diff --git a/lms/djangoapps/instructor_task/tests/test_views.py b/lms/djangoapps/instructor_task/tests/test_views.py
index 41de314abd6d..5dd1e4fd1403 100644
--- a/lms/djangoapps/instructor_task/tests/test_views.py
+++ b/lms/djangoapps/instructor_task/tests/test_views.py
@@ -68,8 +68,10 @@ def test_get_status_from_failure(self):
         self.assertEquals(output['task_id'], task_id)
         self.assertEquals(output['task_state'], FAILURE)
         self.assertFalse(output['in_progress'])
-        expected_progress = {'exception': TEST_FAILURE_EXCEPTION,
-                             'message': TEST_FAILURE_MESSAGE}
+        expected_progress = {
+            'exception': TEST_FAILURE_EXCEPTION,
+            'message': TEST_FAILURE_MESSAGE,
+        }
         self.assertEquals(output['task_progress'], expected_progress)
 
     def test_get_status_from_success(self):
@@ -83,13 +85,70 @@ def test_get_status_from_success(self):
         self.assertEquals(output['task_id'], task_id)
         self.assertEquals(output['task_state'], SUCCESS)
         self.assertFalse(output['in_progress'])
-        expected_progress = {'attempted': 3,
-                             'updated': 2,
-                             'total': 5,
-                             'action_name': 'rescored'}
+        expected_progress = {
+            'attempted': 3,
+            'succeeded': 2,
+            'total': 5,
+            'action_name': 'rescored',
+        }
         self.assertEquals(output['task_progress'], expected_progress)
 
-    def _test_get_status_from_result(self, task_id, mock_result):
+    def test_get_status_from_legacy_success(self):
+        # get status for a task that had already succeeded, back at a time
+        # when 'updated' was used instead of the preferred 'succeeded'.
+        legacy_progress = {
+            'attempted': 3,
+            'updated': 2,
+            'total': 5,
+            'action_name': 'rescored',
+        }
+        instructor_task = self._create_entry(task_state=SUCCESS, task_output=legacy_progress)
+        task_id = instructor_task.task_id
+        response = self._get_instructor_task_status(task_id)
+        output = json.loads(response.content)
+        self.assertEquals(output['message'], "Problem rescored for 2 of 3 students (out of 5)")
+        self.assertEquals(output['succeeded'], False)
+        self.assertEquals(output['task_id'], task_id)
+        self.assertEquals(output['task_state'], SUCCESS)
+        self.assertFalse(output['in_progress'])
+        self.assertEquals(output['task_progress'], legacy_progress)
+
+    def _create_email_subtask_entry(self, total=5, attempted=3, succeeded=2, skipped=0, task_state=PROGRESS):
+        """Create an InstructorTask with subtask defined and email argument."""
+        progress = {'attempted': attempted,
+                    'succeeded': succeeded,
+                    'skipped': skipped,
+                    'total': total,
+                    'action_name': 'emailed',
+                    }
+        instructor_task = self._create_entry(task_state=task_state, task_output=progress)
+        instructor_task.subtasks = {}
+        instructor_task.task_input = json.dumps({'email_id': 134})
+        instructor_task.save()
+        return instructor_task
+
+    def test_get_status_from_subtasks(self):
+        # get status for a task that is in progress, with updates
+        # from subtasks.
+        instructor_task = self._create_email_subtask_entry(skipped=1)
+        task_id = instructor_task.task_id
+        response = self._get_instructor_task_status(task_id)
+        output = json.loads(response.content)
+        self.assertEquals(output['message'], "Progress: emailed 2 of 3 so far (skipping 1) (out of 5)")
+        self.assertEquals(output['succeeded'], False)
+        self.assertEquals(output['task_id'], task_id)
+        self.assertEquals(output['task_state'], PROGRESS)
+        self.assertTrue(output['in_progress'])
+        expected_progress = {
+            'attempted': 3,
+            'succeeded': 2,
+            'skipped': 1,
+            'total': 5,
+            'action_name': 'emailed',
+        }
+        self.assertEquals(output['task_progress'], expected_progress)
+
+    def _test_get_status_from_result(self, task_id, mock_result=None):
         """
         Provides mock result to caller of instructor_task_status, and returns resulting output.
         """
@@ -120,10 +179,12 @@ def test_update_progress_to_progress(self):
         mock_result = Mock()
         mock_result.task_id = task_id
         mock_result.state = PROGRESS
-        mock_result.result = {'attempted': 5,
-                              'updated': 4,
-                              'total': 10,
-                              'action_name': 'rescored'}
+        mock_result.result = {
+            'attempted': 5,
+            'succeeded': 4,
+            'total': 10,
+            'action_name': 'rescored',
+        }
         output = self._test_get_status_from_result(task_id, mock_result)
         self.assertEquals(output['message'], "Progress: rescored 4 of 5 so far (out of 10)")
         self.assertEquals(output['succeeded'], False)
@@ -145,9 +206,11 @@ def test_update_progress_to_failure(self):
         self.assertEquals(output['succeeded'], False)
         self.assertEquals(output['task_state'], FAILURE)
         self.assertFalse(output['in_progress'])
-        expected_progress = {'exception': 'NotImplementedError',
-                             'message': "This task later failed.",
-                             'traceback': "random traceback"}
+        expected_progress = {
+            'exception': 'NotImplementedError',
+            'message': "This task later failed.",
+            'traceback': "random traceback",
+        }
         self.assertEquals(output['task_progress'], expected_progress)
 
     def test_update_progress_to_revoked(self):
@@ -165,7 +228,7 @@ def test_update_progress_to_revoked(self):
         expected_progress = {'message': "Task revoked before running"}
         self.assertEquals(output['task_progress'], expected_progress)
 
-    def _get_output_for_task_success(self, attempted, updated, total, student=None):
+    def _get_output_for_task_success(self, attempted, succeeded, total, student=None):
         """returns the task_id and the result returned by instructor_task_status()."""
         # view task entry for task in progress
         instructor_task = self._create_progress_entry(student)
@@ -173,23 +236,38 @@ def _get_output_for_task_success(self, attempted, updated, total, student=None):
         mock_result = Mock()
         mock_result.task_id = task_id
         mock_result.state = SUCCESS
-        mock_result.result = {'attempted': attempted,
-                              'updated': updated,
-                              'total': total,
-                              'action_name': 'rescored'}
+        mock_result.result = {
+            'attempted': attempted,
+            'succeeded': succeeded,
+            'total': total,
+            'action_name': 'rescored',
+        }
         output = self._test_get_status_from_result(task_id, mock_result)
         return output
 
+    def _get_email_output_for_task_success(self, attempted, succeeded, total, skipped=0):
+        """returns the result returned by instructor_task_status()."""
+        instructor_task = self._create_email_subtask_entry(
+            total=total,
+            attempted=attempted,
+            succeeded=succeeded,
+            skipped=skipped,
+            task_state=SUCCESS,
+        )
+        return self._test_get_status_from_result(instructor_task.task_id)
+
     def test_update_progress_to_success(self):
         output = self._get_output_for_task_success(10, 8, 10)
         self.assertEquals(output['message'], "Problem rescored for 8 of 10 students")
         self.assertEquals(output['succeeded'], False)
         self.assertEquals(output['task_state'], SUCCESS)
         self.assertFalse(output['in_progress'])
-        expected_progress = {'attempted': 10,
-                             'updated': 8,
-                             'total': 10,
-                             'action_name': 'rescored'}
+        expected_progress = {
+            'attempted': 10,
+            'succeeded': 8,
+            'total': 10,
+            'action_name': 'rescored',
+        }
         self.assertEquals(output['task_progress'], expected_progress)
 
     def test_success_messages(self):
@@ -225,6 +303,47 @@ def test_success_messages(self):
         self.assertTrue("Problem successfully rescored for student" in output['message'])
         self.assertTrue(output['succeeded'])
 
+    def test_email_success_messages(self):
+        output = self._get_email_output_for_task_success(0, 0, 10)
+        self.assertEqual(output['message'], "Unable to find any recipients to be emailed (out of 10)")
+        self.assertFalse(output['succeeded'])
+
+        output = self._get_email_output_for_task_success(10, 0, 10)
+        self.assertEqual(output['message'], "Message failed to be emailed for any of 10 recipients ")
+        self.assertFalse(output['succeeded'])
+
+        output = self._get_email_output_for_task_success(10, 8, 10)
+        self.assertEqual(output['message'], "Message emailed for 8 of 10 recipients")
+        self.assertFalse(output['succeeded'])
+
+        output = self._get_email_output_for_task_success(9, 8, 10)
+        self.assertEqual(output['message'], "Message emailed for 8 of 9 recipients (out of 10)")
+        self.assertFalse(output['succeeded'])
+
+        output = self._get_email_output_for_task_success(10, 10, 10)
+        self.assertEqual(output['message'], "Message successfully emailed for 10 recipients")
+        self.assertTrue(output['succeeded'])
+
+        output = self._get_email_output_for_task_success(0, 0, 10, skipped=3)
+        self.assertEqual(output['message'], "Unable to find any recipients to be emailed (skipping 3) (out of 10)")
+        self.assertFalse(output['succeeded'])
+
+        output = self._get_email_output_for_task_success(10, 0, 10, skipped=3)
+        self.assertEqual(output['message'], "Message failed to be emailed for any of 10 recipients  (skipping 3)")
+        self.assertFalse(output['succeeded'])
+
+        output = self._get_email_output_for_task_success(10, 8, 10, skipped=3)
+        self.assertEqual(output['message'], "Message emailed for 8 of 10 recipients (skipping 3)")
+        self.assertFalse(output['succeeded'])
+
+        output = self._get_email_output_for_task_success(9, 8, 10, skipped=3)
+        self.assertEqual(output['message'], "Message emailed for 8 of 9 recipients (skipping 3) (out of 10)")
+        self.assertFalse(output['succeeded'])
+
+        output = self._get_email_output_for_task_success(10, 10, 10, skipped=3)
+        self.assertEqual(output['message'], "Message successfully emailed for 10 recipients (skipping 3)")
+        self.assertTrue(output['succeeded'])
+
     def test_get_info_for_queuing_task(self):
         # get status for a task that is still running:
         instructor_task = self._create_entry()
@@ -262,4 +381,4 @@ def test_get_info_for_broken_input(self):
         instructor_task.task_input = "{ bad"
         succeeded, message = get_task_completion_info(instructor_task)
         self.assertFalse(succeeded)
-        self.assertEquals(message, "Problem rescored for 2 of 3 students (out of 5)")
+        self.assertEquals(message, "Status: rescored 2 of 3 (out of 5)")
diff --git a/lms/djangoapps/instructor_task/views.py b/lms/djangoapps/instructor_task/views.py
index 40f128d08e2d..9a2384142576 100644
--- a/lms/djangoapps/instructor_task/views.py
+++ b/lms/djangoapps/instructor_task/views.py
@@ -3,6 +3,7 @@
 import logging
 
 from django.http import HttpResponse
+from django.utils.translation import ugettext as _
 
 from celery.states import FAILURE, REVOKED, READY_STATES
 
@@ -40,7 +41,7 @@ def instructor_task_status(request):
 
     Status is returned as a JSON-serialized dict, wrapped as the content of a HTTPResponse.
 
-    The task_id can be specified to this view in one of three ways:
+    The task_id can be specified to this view in one of two ways:
 
     * by making a request containing 'task_id' as a parameter with a single value
       Returns a dict containing status information for the specified task_id
@@ -65,7 +66,7 @@ def instructor_task_status(request):
       'in_progress': boolean indicating if task is still running.
       'task_progress': dict containing progress information.  This includes:
           'attempted': number of attempts made
-          'updated': number of attempts that "succeeded"
+          'succeeded': number of attempts that "succeeded"
           'total': number of possible subtasks to attempt
           'action_name': user-visible verb to use in status messages.  Should be past-tense.
           'duration_ms': how long the task has (or had) been running.
@@ -105,68 +106,118 @@ def get_task_completion_info(instructor_task):
     succeeded = False
 
     if instructor_task.task_state not in STATES_WITH_STATUS:
-        return (succeeded, "No status information available")
+        return (succeeded, _("No status information available"))
 
     # we're more surprised if there is no output for a completed task, but just warn:
     if instructor_task.task_output is None:
-        log.warning("No task_output information found for instructor_task {0}".format(instructor_task.task_id))
-        return (succeeded, "No status information available")
+        log.warning(_("No task_output information found for instructor_task {0}").format(instructor_task.task_id))
+        return (succeeded, _("No status information available"))
 
     try:
         task_output = json.loads(instructor_task.task_output)
     except ValueError:
-        fmt = "No parsable task_output information found for instructor_task {0}: {1}"
+        fmt = _("No parsable task_output information found for instructor_task {0}: {1}")
         log.warning(fmt.format(instructor_task.task_id, instructor_task.task_output))
-        return (succeeded, "No parsable status information available")
+        return (succeeded, _("No parsable status information available"))
 
     if instructor_task.task_state in [FAILURE, REVOKED]:
-        return (succeeded, task_output.get('message', 'No message provided'))
+        return (succeeded, task_output.get('message', _('No message provided')))
 
-    if any([key not in task_output for key in ['action_name', 'attempted', 'updated', 'total']]):
-        fmt = "Invalid task_output information found for instructor_task {0}: {1}"
+    if any([key not in task_output for key in ['action_name', 'attempted', 'total']]):
+        fmt = _("Invalid task_output information found for instructor_task {0}: {1}")
         log.warning(fmt.format(instructor_task.task_id, instructor_task.task_output))
-        return (succeeded, "No progress status information available")
+        return (succeeded, _("No progress status information available"))
 
-    action_name = task_output['action_name']
+    action_name = _(task_output['action_name'])
     num_attempted = task_output['attempted']
-    num_updated = task_output['updated']
     num_total = task_output['total']
 
+    # In earlier versions of this code, the key 'updated' was used instead of
+    # (the more general) 'succeeded'.  In order to support history that may contain
+    # output with the old key, we check for values with both the old and the current
+    # key, and simply sum them.
+    num_succeeded = task_output.get('updated', 0) + task_output.get('succeeded', 0)
+    num_skipped = task_output.get('skipped', 0)
+
     student = None
+    problem_url = None
+    email_id = None
     try:
         task_input = json.loads(instructor_task.task_input)
     except ValueError:
-        fmt = "No parsable task_input information found for instructor_task {0}: {1}"
+        fmt = _("No parsable task_input information found for instructor_task {0}: {1}")
         log.warning(fmt.format(instructor_task.task_id, instructor_task.task_input))
     else:
         student = task_input.get('student')
+        problem_url = task_input.get('problem_url')
+        email_id = task_input.get('email_id')
 
     if instructor_task.task_state == PROGRESS:
         # special message for providing progress updates:
-        msg_format = "Progress: {action} {updated} of {attempted} so far"
-    elif student is not None:
+        # Translators: {action} is a past-tense verb that is localized separately. {attempted} and {succeeded} are counts.
+        msg_format = _("Progress: {action} {succeeded} of {attempted} so far")
+    elif student is not None and problem_url is not None:
+        # this reports on actions on problems for a particular student:
         if num_attempted == 0:
-            msg_format = "Unable to find submission to be {action} for student '{student}'"
-        elif num_updated == 0:
-            msg_format = "Problem failed to be {action} for student '{student}'"
+            # Translators: {action} is a past-tense verb that is localized separately. {student} is a student identifier.
+            msg_format = _("Unable to find submission to be {action} for student '{student}'")
+        elif num_succeeded == 0:
+            # Translators: {action} is a past-tense verb that is localized separately. {student} is a student identifier.
+            msg_format = _("Problem failed to be {action} for student '{student}'")
         else:
             succeeded = True
-            msg_format = "Problem successfully {action} for student '{student}'"
-    elif num_attempted == 0:
-        msg_format = "Unable to find any students with submissions to be {action}"
-    elif num_updated == 0:
-        msg_format = "Problem failed to be {action} for any of {attempted} students"
-    elif num_updated == num_attempted:
-        succeeded = True
-        msg_format = "Problem successfully {action} for {attempted} students"
-    else:  # num_updated < num_attempted
-        msg_format = "Problem {action} for {updated} of {attempted} students"
+            # Translators: {action} is a past-tense verb that is localized separately. {student} is a student identifier.
+            msg_format = _("Problem successfully {action} for student '{student}'")
+    elif student is None and problem_url is not None:
+        # this reports on actions on problems for all students:
+        if num_attempted == 0:
+            # Translators: {action} is a past-tense verb that is localized separately.
+            msg_format = _("Unable to find any students with submissions to be {action}")
+        elif num_succeeded == 0:
+            # Translators: {action} is a past-tense verb that is localized separately. {attempted} is a count.
+            msg_format = _("Problem failed to be {action} for any of {attempted} students")
+        elif num_succeeded == num_attempted:
+            succeeded = True
+            # Translators: {action} is a past-tense verb that is localized separately. {attempted} is a count.
+            msg_format = _("Problem successfully {action} for {attempted} students")
+        else:  # num_succeeded < num_attempted
+            # Translators: {action} is a past-tense verb that is localized separately. {succeeded} and {attempted} are counts.
+            msg_format = _("Problem {action} for {succeeded} of {attempted} students")
+    elif email_id is not None:
+        # this reports on actions on bulk emails
+        if num_attempted == 0:
+            # Translators: {action} is a past-tense verb that is localized separately.
+            msg_format = _("Unable to find any recipients to be {action}")
+        elif num_succeeded == 0:
+            # Translators: {action} is a past-tense verb that is localized separately. {attempted} is a count.
+            msg_format = _("Message failed to be {action} for any of {attempted} recipients ")
+        elif num_succeeded == num_attempted:
+            succeeded = True
+            # Translators: {action} is a past-tense verb that is localized separately. {attempted} is a count.
+            msg_format = _("Message successfully {action} for {attempted} recipients")
+        else:  # num_succeeded < num_attempted
+            # Translators: {action} is a past-tense verb that is localized separately. {succeeded} and {attempted} are counts.
+            msg_format = _("Message {action} for {succeeded} of {attempted} recipients")
+    else:
+        # provide a default:
+        # Translators: {action} is a past-tense verb that is localized separately. {succeeded} and {attempted} are counts.
+        msg_format = _("Status: {action} {succeeded} of {attempted}")
+
+    if num_skipped > 0:
+        # Translators: {skipped} is a count.  This message is appended to task progress status messages.
+        msg_format += _(" (skipping {skipped})")
 
     if student is None and num_attempted != num_total:
-        msg_format += " (out of {total})"
+        # Translators: {total} is a count.  This message is appended to task progress status messages.
+        msg_format += _(" (out of {total})")
 
     # Update status in task result object itself:
-    message = msg_format.format(action=action_name, updated=num_updated,
-                                attempted=num_attempted, total=num_total,
-                                student=student)
+    message = msg_format.format(
+        action=action_name,
+        succeeded=num_succeeded,
+        attempted=num_attempted,
+        total=num_total,
+        skipped=num_skipped,
+        student=student
+    )
     return (succeeded, message)
diff --git a/lms/envs/acceptance.py b/lms/envs/acceptance.py
index 7d2ad15e6c8e..4c3d096f1573 100644
--- a/lms/envs/acceptance.py
+++ b/lms/envs/acceptance.py
@@ -74,6 +74,14 @@ def seed():
     }
 }
 
+TRACKING_BACKENDS.update({
+    'mongo': {
+        'ENGINE': 'track.backends.mongodb.MongoBackend'
+    }
+})
+
+DEFAULT_BULK_FROM_EMAIL = "test@test.org"
+
 # Forums are disabled in test.py to speed up unit tests, but we do not have
 # per-test control for acceptance tests
 MITX_FEATURES['ENABLE_DISCUSSION_SERVICE'] = True
@@ -84,6 +92,9 @@ def seed():
 # Enable fake payment processing page
 MITX_FEATURES['ENABLE_PAYMENT_FAKE'] = True
 
+# Enable email on the instructor dash
+MITX_FEATURES['ENABLE_INSTRUCTOR_EMAIL'] = True
+
 # Configure the payment processor to use the fake processing page
 # Since both the fake payment page and the shoppingcart app are using
 # the same settings, we can generate this randomly and guarantee
diff --git a/lms/envs/aws.py b/lms/envs/aws.py
index 86d3d539bd5c..ab6f93a7e321 100644
--- a/lms/envs/aws.py
+++ b/lms/envs/aws.py
@@ -107,8 +107,6 @@
 EMAIL_HOST = ENV_TOKENS.get('EMAIL_HOST', 'localhost')  # django default is localhost
 EMAIL_PORT = ENV_TOKENS.get('EMAIL_PORT', 25)  # django default is 25
 EMAIL_USE_TLS = ENV_TOKENS.get('EMAIL_USE_TLS', False)  # django default is False
-EMAILS_PER_TASK = ENV_TOKENS.get('EMAILS_PER_TASK', 100)
-EMAILS_PER_QUERY = ENV_TOKENS.get('EMAILS_PER_QUERY', 1000)
 SITE_NAME = ENV_TOKENS['SITE_NAME']
 SESSION_ENGINE = ENV_TOKENS.get('SESSION_ENGINE', SESSION_ENGINE)
 SESSION_COOKIE_DOMAIN = ENV_TOKENS.get('SESSION_COOKIE_DOMAIN')
@@ -128,10 +126,9 @@
 
 CACHES = ENV_TOKENS['CACHES']
 
-#Email overrides
+# Email overrides
 DEFAULT_FROM_EMAIL = ENV_TOKENS.get('DEFAULT_FROM_EMAIL', DEFAULT_FROM_EMAIL)
 DEFAULT_FEEDBACK_EMAIL = ENV_TOKENS.get('DEFAULT_FEEDBACK_EMAIL', DEFAULT_FEEDBACK_EMAIL)
-DEFAULT_BULK_FROM_EMAIL = ENV_TOKENS.get('DEFAULT_BULK_FROM_EMAIL', DEFAULT_BULK_FROM_EMAIL)
 ADMINS = ENV_TOKENS.get('ADMINS', ADMINS)
 SERVER_EMAIL = ENV_TOKENS.get('SERVER_EMAIL', SERVER_EMAIL)
 TECH_SUPPORT_EMAIL = ENV_TOKENS.get('TECH_SUPPORT_EMAIL', TECH_SUPPORT_EMAIL)
@@ -141,7 +138,21 @@
 PAID_COURSE_REGISTRATION_CURRENCY = ENV_TOKENS.get('PAID_COURSE_REGISTRATION_CURRENCY',
                                                    PAID_COURSE_REGISTRATION_CURRENCY)
 
-#Theme overrides
+# Bulk Email overrides
+BULK_EMAIL_DEFAULT_FROM_EMAIL = ENV_TOKENS.get('BULK_EMAIL_DEFAULT_FROM_EMAIL', BULK_EMAIL_DEFAULT_FROM_EMAIL)
+BULK_EMAIL_EMAILS_PER_TASK = ENV_TOKENS.get('BULK_EMAIL_EMAILS_PER_TASK', BULK_EMAIL_EMAILS_PER_TASK)
+BULK_EMAIL_EMAILS_PER_QUERY = ENV_TOKENS.get('BULK_EMAIL_EMAILS_PER_QUERY', BULK_EMAIL_EMAILS_PER_QUERY)
+BULK_EMAIL_DEFAULT_RETRY_DELAY = ENV_TOKENS.get('BULK_EMAIL_DEFAULT_RETRY_DELAY', BULK_EMAIL_DEFAULT_RETRY_DELAY)
+BULK_EMAIL_MAX_RETRIES = ENV_TOKENS.get('BULK_EMAIL_MAX_RETRIES', BULK_EMAIL_MAX_RETRIES)
+BULK_EMAIL_INFINITE_RETRY_CAP = ENV_TOKENS.get('BULK_EMAIL_INFINITE_RETRY_CAP', BULK_EMAIL_INFINITE_RETRY_CAP)
+BULK_EMAIL_LOG_SENT_EMAILS = ENV_TOKENS.get('BULK_EMAIL_LOG_SENT_EMAILS', BULK_EMAIL_LOG_SENT_EMAILS)
+BULK_EMAIL_RETRY_DELAY_BETWEEN_SENDS = ENV_TOKENS.get('BULK_EMAIL_RETRY_DELAY_BETWEEN_SENDS', BULK_EMAIL_RETRY_DELAY_BETWEEN_SENDS)
+# We want Bulk Email running on the high-priority queue, so we define the
+# routing key that points to it.  At the moment, the name is the same.
+# We have to reset the value here, since we have changed the value of the queue name.
+BULK_EMAIL_ROUTING_KEY = HIGH_PRIORITY_QUEUE
+
+# Theme overrides
 THEME_NAME = ENV_TOKENS.get('THEME_NAME', None)
 if not THEME_NAME is None:
     enable_theme(THEME_NAME)
@@ -150,10 +161,10 @@
 # Marketing link overrides
 MKTG_URL_LINK_MAP.update(ENV_TOKENS.get('MKTG_URL_LINK_MAP', {}))
 
-#Timezone overrides
+# Timezone overrides
 TIME_ZONE = ENV_TOKENS.get('TIME_ZONE', TIME_ZONE)
 
-#Additional installed apps
+# Additional installed apps
 for app in ENV_TOKENS.get('ADDL_INSTALLED_APPS', []):
     INSTALLED_APPS += (app,)
 
diff --git a/lms/envs/common.py b/lms/envs/common.py
index 96b304294d3d..2a17accf9996 100644
--- a/lms/envs/common.py
+++ b/lms/envs/common.py
@@ -114,7 +114,12 @@
     # analytics experiments
     'ENABLE_INSTRUCTOR_ANALYTICS': False,
 
-    'ENABLE_INSTRUCTOR_EMAIL': False,
+    # Enables the LMS bulk email feature for course staff
+    'ENABLE_INSTRUCTOR_EMAIL': True,
+    # If True and ENABLE_INSTRUCTOR_EMAIL: Forces email to be explicitly turned on
+    #   for each course via django-admin interface.
+    # If False and ENABLE_INSTRUCTOR_EMAIL: Email will be turned on by default for all courses.
+    'REQUIRE_COURSE_EMAIL_AUTH': True,
 
     # enable analytics server.
     # WARNING: THIS SHOULD ALWAYS BE SET TO FALSE UNDER NORMAL
@@ -333,7 +338,7 @@
     }
 }
 
-# Backawrds compatibility with ENABLE_SQL_TRACKING_LOGS feature flag.
+# Backwards compatibility with ENABLE_SQL_TRACKING_LOGS feature flag.
 # In the future, adding the backend to TRACKING_BACKENDS enough.
 if MITX_FEATURES.get('ENABLE_SQL_TRACKING_LOGS'):
     TRACKING_BACKENDS.update({
@@ -414,12 +419,9 @@
 ROOT_URLCONF = 'lms.urls'
 IGNORABLE_404_ENDS = ('favicon.ico')
 
-# Email
+# Platform Email
 EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
 DEFAULT_FROM_EMAIL = 'registration@edx.org'
-DEFAULT_BULK_FROM_EMAIL = 'course-updates@edx.org'
-EMAILS_PER_TASK = 100
-EMAILS_PER_QUERY = 1000
 DEFAULT_FEEDBACK_EMAIL = 'feedback@edx.org'
 SERVER_EMAIL = 'devops@edx.org'
 TECH_SUPPORT_EMAIL = 'technical@edx.org'
@@ -567,6 +569,7 @@
     # Instead of AuthenticationMiddleware, we use a cached backed version
     #'django.contrib.auth.middleware.AuthenticationMiddleware',
     'cache_toolbox.middleware.CacheBackedAuthenticationMiddleware',
+    'student.middleware.UserStandingMiddleware',
     'contentserver.middleware.StaticContentServer',
 
     'django.contrib.messages.middleware.MessageMiddleware',
@@ -587,7 +590,7 @@
 
     # catches any uncaught RateLimitExceptions and returns a 403 instead of a 500
     'ratelimitbackend.middleware.RateLimitMiddleware',
-    
+
     # For A/B testing
     'waffle.middleware.WaffleMiddleware',
 )
@@ -628,25 +631,49 @@
 notes_js = sorted(rooted_glob(PROJECT_ROOT / 'static', 'coffee/src/notes/**/*.coffee'))
 
 PIPELINE_CSS = {
-    'application': {
-        'source_filenames': ['sass/application.css'],
-        'output_filename': 'css/lms-application.css',
+    'style-vendor': {
+        'source_filenames': [
+            'css/vendor/font-awesome.css',
+            'css/vendor/jquery.qtip.min.css',
+            'css/vendor/responsive-carousel/responsive-carousel',
+            'css/vendor/responsive-carousel/responsive-carousel.slide',
+        ],
+        'output_filename': 'css/lms-style-vendor.css',
+    },
+    'style-app': {
+        'source_filenames': [
+            'sass/application.css',
+            'sass/ie.css'
+        ],
+        'output_filename': 'css/lms-style-app.css',
     },
-    'course': {
+    'style-app-extend1': {
+        'source_filenames': [
+            'sass/application-extend1.css',
+        ],
+        'output_filename': 'css/lms-style-app-extend1.css',
+    },
+    'style-app-extend2': {
+        'source_filenames': [
+            'sass/application-extend2.css',
+        ],
+        'output_filename': 'css/lms-style-app-extend2.css',
+    },
+    'style-course-vendor': {
         'source_filenames': [
             'js/vendor/CodeMirror/codemirror.css',
             'css/vendor/jquery.treeview.css',
             'css/vendor/ui-lightness/jquery-ui-1.8.22.custom.css',
-            'css/vendor/jquery.qtip.min.css',
             'css/vendor/annotator.min.css',
+        ],
+        'output_filename': 'css/lms-style-course-vendor.css',
+    },
+    'style-course': {
+        'source_filenames': [
             'sass/course.css',
             'xmodule/modules.css',
         ],
-        'output_filename': 'css/lms-course.css',
-    },
-    'ie-fixes': {
-        'source_filenames': ['sass/ie.css'],
-        'output_filename': 'css/lms-ie.css',
+        'output_filename': 'css/lms-style-course.css',
     },
 }
 
@@ -795,6 +822,45 @@
     DEFAULT_PRIORITY_QUEUE: {}
 }
 
+# let logging work as configured:
+CELERYD_HIJACK_ROOT_LOGGER = False
+
+################################ Bulk Email ###################################
+
+# Suffix used to construct 'from' email address for bulk emails.
+# A course-specific identifier is prepended.
+BULK_EMAIL_DEFAULT_FROM_EMAIL = 'no-reply@courseupdates.edx.org'
+
+# Parameters for breaking down course enrollment into subtasks.
+BULK_EMAIL_EMAILS_PER_TASK = 100
+BULK_EMAIL_EMAILS_PER_QUERY = 1000
+
+# Initial delay used for retrying tasks.  Additional retries use
+# longer delays.  Value is in seconds.
+BULK_EMAIL_DEFAULT_RETRY_DELAY = 30
+
+# Maximum number of retries per task for errors that are not related
+# to throttling.
+BULK_EMAIL_MAX_RETRIES = 5
+
+# Maximum number of retries per task for errors that are related to
+# throttling.  If this is not set, then there is no cap on such retries.
+BULK_EMAIL_INFINITE_RETRY_CAP = 1000
+
+# We want Bulk Email running on the high-priority queue, so we define the
+# routing key that points to it.  At the moment, the name is the same.
+BULK_EMAIL_ROUTING_KEY = HIGH_PRIORITY_QUEUE
+
+# Flag to indicate if individual email addresses should be logged as they are sent
+# a bulk email message.
+BULK_EMAIL_LOG_SENT_EMAILS = False
+
+# Delay in seconds to sleep between individual mail messages being sent,
+# when a bulk email task is retried for rate-related reasons.  Choose this
+# value depending on the number of workers that might be sending email in
+# parallel, and what the SES rate is.
+BULK_EMAIL_RETRY_DELAY_BETWEEN_SENDS = 0.02
+
 ################################### APPS ######################################
 INSTALLED_APPS = (
     # Standard ones that are always installed...
diff --git a/lms/envs/dev.py b/lms/envs/dev.py
index c596208b3f5b..ad5fc4eaa0d0 100644
--- a/lms/envs/dev.py
+++ b/lms/envs/dev.py
@@ -28,6 +28,7 @@
 MITX_FEATURES['ENABLE_PSYCHOMETRICS'] = False    # real-time psychometrics (eg item response theory analysis in instructor dashboard)
 MITX_FEATURES['ENABLE_INSTRUCTOR_ANALYTICS'] = True
 MITX_FEATURES['ENABLE_SERVICE_STATUS'] = True
+MITX_FEATURES['ENABLE_INSTRUCTOR_EMAIL'] = True
 MITX_FEATURES['ENABLE_HINTER_INSTRUCTOR_VIEW'] = True
 MITX_FEATURES['ENABLE_INSTRUCTOR_BETA_DASHBOARD'] = True
 MITX_FEATURES['MULTIPLE_ENROLLMENT_ROLES'] = True
diff --git a/lms/static/coffee/src/instructor_dashboard/analytics.coffee b/lms/static/coffee/src/instructor_dashboard/analytics.coffee
index d53b511e1ca2..018b7e9c57c0 100644
--- a/lms/static/coffee/src/instructor_dashboard/analytics.coffee
+++ b/lms/static/coffee/src/instructor_dashboard/analytics.coffee
@@ -1,8 +1,11 @@
-# Analytics Section
+###
+Analytics Section
+
+imports from other modules.
+wrap in (-> ... apply) to defer evaluation
+such that the value can be defined later than this assignment (file load order).
+###
 
-# imports from other modules.
-# wrap in (-> ... apply) to defer evaluation
-# such that the value can be defined later than this assignment (file load order).
 plantTimeout = -> window.InstructorDashboard.util.plantTimeout.apply this, arguments
 std_ajax_err = -> window.InstructorDashboard.util.std_ajax_err.apply this, arguments
 
diff --git a/lms/static/coffee/src/instructor_dashboard/course_info.coffee b/lms/static/coffee/src/instructor_dashboard/course_info.coffee
index d48c7ba87312..19f9ce9707b2 100644
--- a/lms/static/coffee/src/instructor_dashboard/course_info.coffee
+++ b/lms/static/coffee/src/instructor_dashboard/course_info.coffee
@@ -1,10 +1,13 @@
-# Course Info Section
-# This is the implementation of the simplest section
-# of the instructor dashboard.
+###
+Course Info Section
+This is the implementation of the simplest section
+of the instructor dashboard.
+
+imports from other modules.
+wrap in (-> ... apply) to defer evaluation
+such that the value can be defined later than this assignment (file load order).
+###
 
-# imports from other modules.
-# wrap in (-> ... apply) to defer evaluation
-# such that the value can be defined later than this assignment (file load order).
 plantTimeout = -> window.InstructorDashboard.util.plantTimeout.apply this, arguments
 std_ajax_err = -> window.InstructorDashboard.util.std_ajax_err.apply this, arguments
 
diff --git a/lms/static/coffee/src/instructor_dashboard/data_download.coffee b/lms/static/coffee/src/instructor_dashboard/data_download.coffee
index ee9be4254dc9..b5bbde918290 100644
--- a/lms/static/coffee/src/instructor_dashboard/data_download.coffee
+++ b/lms/static/coffee/src/instructor_dashboard/data_download.coffee
@@ -1,8 +1,11 @@
-# Data Download Section
+###
+Data Download Section
+
+imports from other modules.
+wrap in (-> ... apply) to defer evaluation
+such that the value can be defined later than this assignment (file load order).
+###
 
-# imports from other modules.
-# wrap in (-> ... apply) to defer evaluation
-# such that the value can be defined later than this assignment (file load order).
 plantTimeout = -> window.InstructorDashboard.util.plantTimeout.apply this, arguments
 std_ajax_err = -> window.InstructorDashboard.util.std_ajax_err.apply this, arguments
 
diff --git a/lms/static/coffee/src/instructor_dashboard/instructor_dashboard.coffee b/lms/static/coffee/src/instructor_dashboard/instructor_dashboard.coffee
index a7c803f8acaa..c645fcf67e51 100644
--- a/lms/static/coffee/src/instructor_dashboard/instructor_dashboard.coffee
+++ b/lms/static/coffee/src/instructor_dashboard/instructor_dashboard.coffee
@@ -1,26 +1,31 @@
-# Instructor Dashboard Tab Manager
-# The instructor dashboard is broken into sections.
-# Only one section is visible at a time,
-#   and is responsible for its own functionality.
-#
-# NOTE: plantTimeout (which is just setTimeout from util.coffee)
-#       is used frequently in the instructor dashboard to isolate
-#       failures. If one piece of code under a plantTimeout fails
-#       then it will not crash the rest of the dashboard.
-#
-# NOTE: The instructor dashboard currently does not
-#       use backbone. Just lots of jquery. This should be fixed.
-#
-# NOTE: Server endpoints in the dashboard are stored in
-#       the 'data-endpoint' attribute of relevant html elements.
-#       The urls are rendered there by a template.
-#
-# NOTE: For an example of what a section object should look like
-#       see course_info.coffee
-
-# imports from other modules
-# wrap in (-> ... apply) to defer evaluation
-# such that the value can be defined later than this assignment (file load order).
+###
+Instructor Dashboard Tab Manager
+
+The instructor dashboard is broken into sections.
+
+Only one section is visible at a time,
+  and is responsible for its own functionality.
+
+NOTE: plantTimeout (which is just setTimeout from util.coffee)
+      is used frequently in the instructor dashboard to isolate
+      failures. If one piece of code under a plantTimeout fails
+      then it will not crash the rest of the dashboard.
+
+NOTE: The instructor dashboard currently does not
+      use backbone. Just lots of jquery. This should be fixed.
+
+NOTE: Server endpoints in the dashboard are stored in
+      the 'data-endpoint' attribute of relevant html elements.
+      The urls are rendered there by a template.
+
+NOTE: For an example of what a section object should look like
+      see course_info.coffee
+
+imports from other modules
+wrap in (-> ... apply) to defer evaluation
+such that the value can be defined later than this assignment (file load order).
+###
+
 plantTimeout = -> window.InstructorDashboard.util.plantTimeout.apply this, arguments
 std_ajax_err = -> window.InstructorDashboard.util.std_ajax_err.apply this, arguments
 
@@ -156,6 +161,9 @@ setup_instructor_dashboard_sections = (idash_content) ->
   ,
     constructor: window.InstructorDashboard.sections.StudentAdmin
     $element: idash_content.find ".#{CSS_IDASH_SECTION}#student_admin"
+  ,
+    constructor: window.InstructorDashboard.sections.Email
+    $element: idash_content.find ".#{CSS_IDASH_SECTION}#send_email"
   ,
     constructor: window.InstructorDashboard.sections.Analytics
     $element: idash_content.find ".#{CSS_IDASH_SECTION}#analytics"
diff --git a/lms/static/coffee/src/instructor_dashboard/membership.coffee b/lms/static/coffee/src/instructor_dashboard/membership.coffee
index a50cd2c3dd37..54b04be5db6a 100644
--- a/lms/static/coffee/src/instructor_dashboard/membership.coffee
+++ b/lms/static/coffee/src/instructor_dashboard/membership.coffee
@@ -1,8 +1,11 @@
-# Membership Section
+###
+Membership Section
+
+imports from other modules.
+wrap in (-> ... apply) to defer evaluation
+such that the value can be defined later than this assignment (file load order).
+###
 
-# imports from other modules.
-# wrap in (-> ... apply) to defer evaluation
-# such that the value can be defined later than this assignment (file load order).
 plantTimeout = -> window.InstructorDashboard.util.plantTimeout.apply this, arguments
 std_ajax_err = -> window.InstructorDashboard.util.std_ajax_err.apply this, arguments
 
diff --git a/lms/static/coffee/src/instructor_dashboard/send_email.coffee b/lms/static/coffee/src/instructor_dashboard/send_email.coffee
new file mode 100644
index 000000000000..0d1c184ab771
--- /dev/null
+++ b/lms/static/coffee/src/instructor_dashboard/send_email.coffee
@@ -0,0 +1,101 @@
+###
+Email Section
+
+imports from other modules.
+wrap in (-> ... apply) to defer evaluation
+such that the value can be defined later than this assignment (file load order).
+###
+
+plantTimeout = -> window.InstructorDashboard.util.plantTimeout.apply this, arguments
+std_ajax_err = -> window.InstructorDashboard.util.std_ajax_err.apply this, arguments
+
+class SendEmail
+  constructor: (@$container) ->
+    # gather elements
+    @$emailEditor = XModule.loadModule($('.xmodule_edit'));
+    @$send_to = @$container.find("select[name='send_to']'")
+    @$subject = @$container.find("input[name='subject']'")
+    @$btn_send = @$container.find("input[name='send']'")
+    @$task_response = @$container.find(".request-response")
+    @$request_response_error = @$container.find(".request-response-error")
+
+    # attach click handlers
+
+    @$btn_send.click =>
+      if @$subject.val() == ""
+        alert gettext("Your message must have a subject.")
+      else if @$emailEditor.save()['data'] == ""
+        alert gettext("Your message cannot be blank.")
+      else
+        success_message = gettext("Your email was successfully queued for sending.")
+        send_to = @$send_to.val().toLowerCase()
+        if send_to == "myself"
+          send_to = gettext("yourself")
+        else if send_to == "staff"
+          send_to = gettext("everyone who is staff or instructor on this course")
+        else
+          send_to = gettext("ALL (everyone who is enrolled in this course as student, staff, or instructor)")
+          success_message = gettext("Your email was successfully queued for sending.  Please note that for large public classes (~10k), it may take 1-2 hours to send all emails.")
+        subject = gettext(@$subject.val())
+        confirm_message = gettext("You are about to send an email titled \"#{subject}\" to #{send_to}.  Is this OK?")
+        if confirm confirm_message
+
+          send_data =
+            action: 'send'
+            send_to: @$send_to.val()
+            subject: @$subject.val()
+            message: @$emailEditor.save()['data']
+
+          $.ajax
+            type: 'POST'
+            dataType: 'json'
+            url: @$btn_send.data 'endpoint'
+            data: send_data
+            success: (data) => 
+              @display_response success_message
+              
+            error: std_ajax_err => 
+              @fail_with_error gettext('Error sending email.')
+
+        else
+          @$task_response.empty()
+          @$request_response_error.empty()
+              
+  fail_with_error: (msg) ->
+    console.warn msg
+    @$task_response.empty()
+    @$request_response_error.empty()
+    @$request_response_error.text gettext(msg)
+    $(".msg-confirm").css({"display":"none"})
+
+  display_response: (data_from_server) ->
+    @$task_response.empty()
+    @$request_response_error.empty()
+    @$task_response.text(data_from_server)
+    $(".msg-confirm").css({"display":"block"})
+
+
+# Email Section
+class Email
+  # enable subsections.
+  constructor: (@$section) ->
+    # attach self to html
+    # so that instructor_dashboard.coffee can find this object
+    # to call event handlers like 'onClickTitle'
+    @$section.data 'wrapper', @
+
+    # isolate # initialize SendEmail subsection
+    plantTimeout 0, => new SendEmail @$section.find '.send-email'
+
+  # handler for when the section title is clicked.
+  onClickTitle: ->
+
+
+# export for use
+# create parent namespaces if they do not already exist.
+# abort if underscore can not be found.
+if _?
+  _.defaults window, InstructorDashboard: {}
+  _.defaults window.InstructorDashboard, sections: {}
+  _.defaults window.InstructorDashboard.sections,
+    Email: Email
diff --git a/lms/static/coffee/src/instructor_dashboard/student_admin.coffee b/lms/static/coffee/src/instructor_dashboard/student_admin.coffee
index 3e5c8c27c2b8..00ca4d2d45d9 100644
--- a/lms/static/coffee/src/instructor_dashboard/student_admin.coffee
+++ b/lms/static/coffee/src/instructor_dashboard/student_admin.coffee
@@ -1,8 +1,11 @@
-# Student Admin Section
+###
+Student Admin Section
+
+imports from other modules.
+wrap in (-> ... apply) to defer evaluation
+such that the value can be defined later than this assignment (file load order).
+###
 
-# imports from other modules.
-# wrap in (-> ... apply) to defer evaluation
-# such that the value can be defined later than this assignment (file load order).
 plantTimeout = -> window.InstructorDashboard.util.plantTimeout.apply this, arguments
 plantInterval = -> window.InstructorDashboard.util.plantInterval.apply this, arguments
 std_ajax_err = -> window.InstructorDashboard.util.std_ajax_err.apply this, arguments
diff --git a/lms/static/sass/_shame.scss b/lms/static/sass/_shame.scss
index 1c3da1c0f82c..3a27a6ad97e4 100644
--- a/lms/static/sass/_shame.scss
+++ b/lms/static/sass/_shame.scss
@@ -230,3 +230,10 @@
 footer .references {
   @include footer_references_style;
 }
+
+// ====================
+
+// poor cascade made worse by CSS splitting requires us to redefine the dashboard views' visual top padding
+.dashboard {
+  padding-top: 60px;
+}
diff --git a/lms/static/sass/application-extend1.scss.mako b/lms/static/sass/application-extend1.scss.mako
new file mode 100644
index 000000000000..86a442301dd0
--- /dev/null
+++ b/lms/static/sass/application-extend1.scss.mako
@@ -0,0 +1,62 @@
+## NOTE: This Sass infrastructure is redundant, but needed in order to address an IE9 rule limit within CSS - http://blogs.msdn.com/b/ieinternals/archive/2011/05/14/10164546.aspx
+
+
+// lms - css application architecture (platform)
+// ====================
+
+// libs and resets *do not edit*
+@import 'bourbon/bourbon'; // lib - bourbon
+
+// BASE  *default edX offerings*
+// ====================
+
+// base - utilities
+@import 'base/reset';
+@import 'base/mixins';
+@import 'base/variables';
+
+## THEMING
+## -------
+## Set up this file to import an edX theme library if the environment
+## indicates that a theme should be used. The assumption is that the
+## theme resides outside of this main edX repository, in a directory
+## called themes/<theme-name>/, with its base Sass file in
+## themes/<theme-name>/static/sass/_<theme-name>.scss. That one entry
+## point can be used to @import in as many other things as needed.
+% if env.get('THEME_NAME') is not None:
+  // import theme's Sass overrides
+  @import '${env.get('THEME_NAME')}';
+% endif
+
+@import 'base/base';
+
+// base - assets
+@import 'base/font_face';
+@import 'base/extends';
+@import 'base/animations';
+
+// base - starter
+@import 'base/base';
+
+// base - elements
+@import 'elements/typography';
+@import 'elements/controls';
+
+// shared - platform
+@import 'multicourse/home';
+@import 'multicourse/dashboard';
+@import 'multicourse/account';
+@import 'multicourse/testcenter-register';
+@import 'multicourse/courses';
+@import 'multicourse/course_about';
+@import 'multicourse/jobs';
+@import 'multicourse/media-kit';
+@import 'multicourse/about_pages';
+@import 'multicourse/press_release';
+@import 'multicourse/password_reset';
+@import 'multicourse/error-pages';
+@import 'multicourse/help';
+@import 'multicourse/edge';
+
+## NOTE: needed here for cascade and dependency purposes, but not a great permanent solution
+@import 'shame'; // shame file - used for any bad-form/orphaned scss that knowingly violate edX FED architecture/standards (see - http://csswizardry.com/2013/04/shame-css/)
diff --git a/lms/static/sass/application-extend2.scss.mako b/lms/static/sass/application-extend2.scss.mako
new file mode 100644
index 000000000000..32c32e9d2fc0
--- /dev/null
+++ b/lms/static/sass/application-extend2.scss.mako
@@ -0,0 +1,54 @@
+## NOTE: This Sass infrastructure is redundant, but needed in order to address an IE9 rule limit within CSS - http://blogs.msdn.com/b/ieinternals/archive/2011/05/14/10164546.aspx
+
+
+// lms - css application architecture (platform)
+// ====================
+
+// libs and resets *do not edit*
+@import 'bourbon/bourbon'; // lib - bourbon
+
+// BASE  *default edX offerings*
+// ====================
+
+// base - utilities
+@import 'base/reset';
+@import 'base/mixins';
+@import 'base/variables';
+
+## THEMING
+## -------
+## Set up this file to import an edX theme library if the environment
+## indicates that a theme should be used. The assumption is that the
+## theme resides outside of this main edX repository, in a directory
+## called themes/<theme-name>/, with its base Sass file in
+## themes/<theme-name>/static/sass/_<theme-name>.scss. That one entry
+## point can be used to @import in as many other things as needed.
+% if env.get('THEME_NAME') is not None:
+  // import theme's Sass overrides
+  @import '${env.get('THEME_NAME')}';
+% endif
+
+@import 'base/base';
+
+// base - assets
+@import 'base/font_face';
+@import 'base/extends';
+@import 'base/animations';
+
+// base - starter
+@import 'base/base';
+
+// base - elements
+@import 'elements/typography';
+@import 'elements/controls';
+
+// base - specific views
+@import 'views/verification';
+@import 'views/shoppingcart';
+
+// applications
+@import 'discussion';
+@import 'news';
+
+## NOTE: needed here for cascade and dependency purposes, but not a great permanent solution
+@import 'shame'; // shame file - used for any bad-form/orphaned scss that knowingly violate edX FED architecture/standards (see - http://csswizardry.com/2013/04/shame-css/)
diff --git a/lms/static/sass/application.scss.mako b/lms/static/sass/application.scss.mako
index a5007481218b..16688d5368e0 100644
--- a/lms/static/sass/application.scss.mako
+++ b/lms/static/sass/application.scss.mako
@@ -1,21 +1,16 @@
+## Note: This Sass infrastructure is repeated in application-extend1 and application-extend2, but needed in order to address an IE9 rule limit within CSS - http://blogs.msdn.com/b/ieinternals/archive/2011/05/14/10164546.aspx
+
 // lms - css application architecture
 // ====================
 
 // libs and resets *do not edit*
 @import 'bourbon/bourbon'; // lib - bourbon
 
-// VENDOR + REBASE *referenced/used vendor presentation and reset*
-// ====================
-
-@import 'base/reset';
-@import 'vendor/font-awesome';
-@import 'vendor/responsive-carousel/responsive-carousel';
-@import 'vendor/responsive-carousel/responsive-carousel.slide';
-
 // BASE  *default edX offerings*
 // ====================
-// base - utilities
 
+// base - utilities
+@import 'base/reset';
 @import 'base/mixins';
 @import 'base/variables';
 
@@ -46,10 +41,6 @@
 @import 'elements/typography';
 @import 'elements/controls';
 
-// base - specific views
-@import 'views/verification';
-@import 'views/shoppingcart';
-
 // shared - course
 @import 'shared/forms';
 @import 'shared/footer';
@@ -60,24 +51,5 @@
 @import 'shared/activation_messages';
 @import 'shared/unsubscribe';
 
-// shared - platform
-@import 'multicourse/home';
-@import 'multicourse/dashboard';
-@import 'multicourse/account';
-@import 'multicourse/testcenter-register';
-@import 'multicourse/courses';
-@import 'multicourse/course_about';
-@import 'multicourse/jobs';
-@import 'multicourse/media-kit';
-@import 'multicourse/about_pages';
-@import 'multicourse/press_release';
-@import 'multicourse/password_reset';
-@import 'multicourse/error-pages';
-@import 'multicourse/help';
-@import 'multicourse/edge';
-
-// applications
-@import 'discussion';
-@import 'news';
-
+## NOTE: needed here for cascade and dependency purposes, but not a great permanent solution
 @import 'shame'; // shame file - used for any bad-form/orphaned scss that knowingly violate edX FED architecture/standards (see - http://csswizardry.com/2013/04/shame-css/)
diff --git a/lms/static/sass/base/_variables.scss b/lms/static/sass/base/_variables.scss
index 9d8820e36971..c1bbcd5d6fb1 100644
--- a/lms/static/sass/base/_variables.scss
+++ b/lms/static/sass/base/_variables.scss
@@ -219,6 +219,11 @@ $action-secondary-disabled-fg: $white;
 $header-graphic-super-color: $m-blue-d1;
 $header-graphic-sub-color: $m-gray-d2;
 
+// State-based colors
+$error-color: $error-red;
+$warning-color: $m-pink;
+$confirm-color: $m-green;
+
 // ====================
 
 // MISC: visual horizontal rules
diff --git a/lms/static/sass/course/instructor/_instructor_2.scss b/lms/static/sass/course/instructor/_instructor_2.scss
index 61dab3ef1c8c..947c4df41de5 100644
--- a/lms/static/sass/course/instructor/_instructor_2.scss
+++ b/lms/static/sass/course/instructor/_instructor_2.scss
@@ -18,6 +18,74 @@
     right: 15px;
     font-size: 11pt;
   }
+
+  // system feedback - messages
+  .msg {
+    border-radius: 1px;
+    padding: $baseline/2 $baseline*0.75;
+    margin-bottom: $baseline;
+    font-weight: 600;
+
+    .copy {
+      font-weight: 600;
+    }
+  }
+
+  // TYPE: warning
+  .msg-warning {
+    border-top: 2px solid $warning-color;
+    background: tint($warning-color,95%);
+
+    .copy {
+      color: $warning-color;
+    }
+  }
+
+  // TYPE: confirm
+  .msg-confirm {
+    border-top: 2px solid $confirm-color;
+    background: tint($confirm-color,95%);
+    display: none;
+    color: $confirm-color;
+  }
+
+  // TYPE: confirm
+  .msg-error {
+    border-top: 2px solid $error-color;
+    background: tint($error-color,95%);
+
+    .copy {
+      color: $error-color;
+    }
+  }
+
+  // inline copy
+  .copy-confirm {
+    color: $confirm-color;
+  }
+
+  .copy-warning {
+    color: $warning-color;
+  }
+
+  .copy-error {
+    color: $error-color;
+  }
+
+  .list-advice {
+    list-style: none;
+    padding: 0;
+    margin: $baseline 0;
+
+    .item {
+      font-weight: 600;
+      margin-bottom: 10px;
+
+      &:last-child {
+        margin-bottom: 0;
+      }
+    }
+  }
 }
 
 section.instructor-dashboard-content-2 {
@@ -110,7 +178,6 @@ section.instructor-dashboard-content-2 {
   }
 }
 
-
 .instructor-dashboard-wrapper-2 section.idash-section#course_info {
   .course-errors-wrapper {
     margin-top: 2em;
@@ -173,6 +240,24 @@ section.instructor-dashboard-content-2 {
   }
 }
 
+.instructor-dashboard-wrapper-2 section.idash-section#send_email {
+  // form fields
+  .list-fields {
+    list-style: none;
+    margin: 0;
+    padding: 0;
+
+    .field {
+      margin-bottom: $baseline;
+      padding: 0;
+
+      &:last-child {
+        margin-bottom: 0;
+      }
+    }
+  }
+}
+
 
 .instructor-dashboard-wrapper-2 section.idash-section#membership {
   $half_width: $baseline * 20;
@@ -470,3 +555,7 @@ section.instructor-dashboard-content-2 {
     right: $baseline;
   }
 }
+
+input[name="subject"] {
+  width:600px;
+}
diff --git a/lms/static/sass/elements/_typography.scss b/lms/static/sass/elements/_typography.scss
index 043a205278d9..2cf11ce79bb7 100644
--- a/lms/static/sass/elements/_typography.scss
+++ b/lms/static/sass/elements/_typography.scss
@@ -194,3 +194,92 @@
 %t-weight5 {
   font-weight: 700;
 }
+
+// ====================
+
+// MISC: extends - type
+// application: canned headings
+%hd-lv1 {
+  @extend %t-title1;
+  @extend %t-weight1;
+  color: $m-gray-d4;
+  margin: 0 0 ($baseline*2) 0;
+}
+
+%hd-lv2 {
+  @extend %t-title4;
+  @extend %t-weight1;
+  margin: 0 0 ($baseline*0.75) 0;
+  border-bottom: 1px solid $m-gray-l3;
+  padding-bottom: ($baseline/2);
+  color: $m-gray-d4;
+}
+
+%hd-lv3 {
+  @extend %t-title6;
+  @extend %t-weight4;
+  margin: 0 0 ($baseline/4) 0;
+  color: $m-gray-d4;
+}
+
+%hd-lv4 {
+  @extend %t-title6;
+  @extend %t-weight2;
+  margin: 0 0 $baseline 0;
+  color: $m-gray-d4;
+}
+
+%hd-lv5 {
+  @extend %t-title7;
+  @extend %t-weight4;
+  margin: 0 0 ($baseline/4) 0;
+  color: $m-gray-d4;
+}
+
+// application: canned copy
+%copy-base {
+  @extend %t-copy-base;
+  color: $m-gray-d2;
+}
+
+%copy-lead1 {
+  @extend %t-copy-lead2;
+  color: $m-gray;
+}
+
+%copy-detail {
+  @extend %t-copy-sub1;
+  @extend %t-weight3;
+  color: $m-gray-d1;
+}
+
+%copy-metadata {
+  @extend %t-copy-sub2;
+  color: $m-gray-d1;
+
+
+  %copy-metadata-value {
+    @extend %t-weight2;
+  }
+
+  %copy-metadata-value {
+    @extend %t-weight4;
+  }
+}
+
+// application: canned links
+%copy-link {
+  border-bottom: 1px dotted transparent;
+
+  &:hover, &:active {
+    border-color: $link-color-d1;
+  }
+}
+
+%copy-badge {
+  @extend %t-title8;
+  @extend %t-weight5;
+  border-radius: ($baseline/5);
+  padding: ($baseline/2) $baseline;
+  text-transform: uppercase;
+}
diff --git a/lms/static/sass/ie.scss b/lms/static/sass/ie.scss
index 87a8b07fe63c..9ba7e612c1d3 100644
--- a/lms/static/sass/ie.scss
+++ b/lms/static/sass/ie.scss
@@ -2,184 +2,188 @@
 @import "base/variables";
 
 // These are all quick solutions for IE please rewrite
-//Make overlay white because ie doesn't like rgba
-.highlighted-courses .courses .course header.course-preview, .find-courses .courses .course header.course-preview,
-.home .highlighted-courses > h2, .home .highlighted-courses > section.outside-app h1, section.outside-app .home .highlighted-courses > h1,
-header.global {
-  background: #FFF;
-}
+.ie {
 
-// hide all actions
-.home > header .title .actions,
-.home > header .title:hover .actions {
-  display: none;
-  height: auto;
-}
+  //Make overlay white because ie doesn't like rgba
+  .highlighted-courses .courses .course header.course-preview, .find-courses .courses .course header.course-preview,
+  .home .highlighted-courses > h2, .home .highlighted-courses > section.outside-app h1, section.outside-app .home .highlighted-courses > h1,
+  header.global {
+    background: #FFF;
+  }
+
+  // hide all actions
+  .home > header .title .actions,
+  .home > header .title:hover .actions {
+    display: none;
+    height: auto;
+  }
 
-.home > header .title {
-  &:hover {
+  .home > header .title {
+    &:hover {
 
-    > hgroup {
-      h1 {
-        border-bottom: 0;
-        padding-bottom: 0;
-      }
+      > hgroup {
+        h1 {
+          border-bottom: 0;
+          padding-bottom: 0;
+        }
 
-      h2 {
-        opacity: 1.0;
+        h2 {
+          opacity: 1.0;
+        }
       }
-    }
 
-    .actions {
-      opacity: 0;
+      .actions {
+        opacity: 0;
+      }
     }
   }
-}
 
-// because ie doesn't like :last
-.last {
-  margin-right: 0  !important;
-}
-
-// make partners not animate
-.home .university-partners .partners a {
-  .name {
-    position: static;
+  // because ie doesn't like :last
+  .last {
+    margin-right: 0  !important;
   }
 
-  &:hover {
-    text-decoration: none;
-
-    &::before {
-      opacity: 1.0;
-    }
-
+  // make partners not animate
+  .home .university-partners .partners a {
     .name {
-      bottom: 0px;
+      position: static;
     }
 
-    img {
-      top: 0px;
-    }
-  }
+    &:hover {
+      text-decoration: none;
 
-}
+      &::before {
+        opacity: 1.0;
+      }
 
-.home .university-partners .partners {
-  width: 660px;
+      .name {
+        bottom: 0px;
+      }
 
-  li.partner {
-    float: left;
-    display: block;
-    padding: 0;
-    width: 220px;
-    overflow: hidden;
-  }
-}
+      img {
+        top: 0px;
+      }
+    }
 
-// make animations on homepage not animate and show everything
-.highlighted-courses .courses .course, .find-courses .courses .course {
-  .meta-info {
-    display: none;
   }
 
-  .inner-wrapper {
-    height: 100%;
-    overflow: visible;
-    position: relative;
+  .home .university-partners .partners {
+    width: 660px;
+
+    li.partner {
+      float: left;
+      display: block;
+      padding: 0;
+      width: 220px;
+      overflow: hidden;
+    }
   }
 
-  header.course-preview {
-    left: 0px;
-    position: relative;
-    top: 0px;
-    width: 100%;
-    z-index: 3;
-    height: auto;
+  // make animations on homepage not animate and show everything
+  .highlighted-courses .courses .course, .find-courses .courses .course {
+    .meta-info {
+      display: none;
+    }
 
-    hgroup {
+    .inner-wrapper {
+      height: 100%;
+      overflow: visible;
       position: relative;
-      right: 0;
-      top: 0;
     }
 
-  }
+    header.course-preview {
+      left: 0px;
+      position: relative;
+      top: 0px;
+      width: 100%;
+      z-index: 3;
+      height: auto;
 
-  .info {
-    height: auto;
-    position: static;
-    overflow: visible;
+      hgroup {
+        position: relative;
+        right: 0;
+        top: 0;
+      }
 
-    .desc {
-      height: auto;
     }
-  }
-
-  &:hover {
-    background: rgb(245,245,245);
-    border-color: rgb(170,170,170);
-    box-shadow: 0 1px 16px 0 rgba($blue, 0.4);
 
     .info {
-      top: 0;
-    }
+      height: auto;
+      position: static;
+      overflow: visible;
 
-    .meta-info {
-      opacity: 0;
+      .desc {
+        height: auto;
+      }
     }
-  }
-}
 
-// make overlay flat black since IE cant handle rgba
-#lean_overlay {
-  background: #000;
-}
+    &:hover {
+      background: rgb(245,245,245);
+      border-color: rgb(170,170,170);
+      box-shadow: 0 1px 16px 0 rgba($blue, 0.4);
 
-// active navigation
-nav.course-material ol.course-tabs li a.active, nav.course-material .xmodule_SequenceModule nav.sequence-nav ol.course-tabs li a.seq_video.active, .xmodule_SequenceModule nav.sequence-nav nav.course-material ol.course-tabs li a.seq_video.active {
-  background-color: #333;
-  background-color: rgba(0, 0, 0, .4);
-}
+      .info {
+        top: 0;
+      }
 
-// make dropdown user consistent size
-header.global ol.user > li.primary a.dropdown {
-  padding-top: 6px;
-  padding-bottom: 6px;
-}
+      .meta-info {
+        opacity: 0;
+      }
+    }
+  }
 
-// always hide arrow in IE
-.dashboard .my-courses .my-course .cover .arrow {
-  display: none;
-}
+  // make overlay flat black since IE cant handle rgba
+  #lean_overlay {
+    background: #000;
+  }
 
-.ie-banner {
-  display: block !important;
-}
+  // active navigation
+  nav.course-material ol.course-tabs li a.active, nav.course-material .xmodule_SequenceModule nav.sequence-nav ol.course-tabs li a.seq_video.active, .xmodule_SequenceModule nav.sequence-nav nav.course-material ol.course-tabs li a.seq_video.active {
+    background-color: #333;
+    background-color: rgba(0, 0, 0, .4);
+  }
 
-div.course-wrapper {
-  display: block !important;
+  // make dropdown user consistent size
+  header.global ol.user > li.primary a.dropdown {
+    padding-top: 6px;
+    padding-bottom: 6px;
+  }
 
-  section.course-content,
-  section.course-index {
-    display: block !important;
-    float: left;
+  // always hide arrow in IE
+  .dashboard .my-courses .my-course .cover .arrow {
+    display: none;
   }
 
-  section.course-content {
-    width: 71.27%;
+  .ie-banner {
+    display: block !important;
   }
-}
 
-.sidebar {
-  float: left !important;
-  display: block !important;
-}
+  div.course-wrapper {
+    display: block !important;
 
-.sequence-nav ol {
-  display: block !important;
+    section.course-content,
+    section.course-index {
+      display: block !important;
+      float: left;
+    }
 
-  li {
+    section.course-content {
+      width: 71.27%;
+    }
+  }
+
+  .sidebar {
     float: left !important;
-    width: 50px;
+    display: block !important;
   }
+
+  .sequence-nav ol {
+    display: block !important;
+
+    li {
+      float: left !important;
+      width: 50px;
+    }
+  }
+
 }
diff --git a/lms/static/sass/vendor/_font-awesome.scss b/lms/static/sass/vendor/_font-awesome.scss
deleted file mode 100644
index 035ca8c7505e..000000000000
--- a/lms/static/sass/vendor/_font-awesome.scss
+++ /dev/null
@@ -1,1268 +0,0 @@
-/*!
- *  Font Awesome 3.1.0
- *  the iconic font designed for Bootstrap
- *  -------------------------------------------------------
- *  The full suite of pictographic icons, examples, and documentation
- *  can be found at: http://fontawesome.io
- *
- *  License
- *  -------------------------------------------------------
- *  - The Font Awesome font is licensed under the SIL Open Font License v1.1 -
- *    http://scripts.sil.org/OFL
- *  - Font Awesome CSS, LESS, and SASS files are licensed under the MIT License -
- *    http://opensource.org/licenses/mit-license.html
- *  - Font Awesome documentation licensed under CC BY 3.0 License -
- *    http://creativecommons.org/licenses/by/3.0/
- *  - Attribution is no longer required in Font Awesome 3.0, but much appreciated:
- *    "Font Awesome by Dave Gandy - http://fontawesome.io"
-
- *  Contact
- *  -------------------------------------------------------
- *  Email: dave@fontawesome.io
- *  Twitter: http://twitter.com/fortaweso_me
- *  Work: Lead Product Designer @ http://kyruus.com
- */
-/* FONT PATH
- * -------------------------- */
-@font-face {
-  font-family: 'FontAwesome';
-  src: url('../fonts/vendor/fontawesome-webfont.eot?v=3.1.0');
-  src: url('../fonts/vendor/fontawesome-webfont.eot?#iefix&v=3.1.0') format('embedded-opentype'), url('../fonts/vendor/fontawesome-webfont.woff?v=3.1.0') format('woff'), url('../fonts/vendor/fontawesome-webfont.ttf?v=3.1.0') format('truetype'), url('../fonts/vendor/fontawesome-webfont.svg#fontawesomeregular?v=3.1.0') format('svg');
-  font-weight: normal;
-  font-style: normal;
-}
-/* FONT AWESOME CORE
- * -------------------------- */
-[class^="icon-"],
-[class*=" icon-"] {
-  font-family: FontAwesome;
-  font-weight: normal;
-  font-style: normal;
-  text-decoration: inherit;
-  -webkit-font-smoothing: antialiased;
-  *margin-right: .3em;
-}
-[class^="icon-"]:before,
-[class*=" icon-"]:before {
-  text-decoration: inherit;
-  display: inline-block;
-  speak: none;
-}
-/* makes the font 33% larger relative to the icon container */
-.icon-large:before {
-  vertical-align: -10%;
-  font-size: 1.3333333333333333em;
-}
-/* makes sure icons active on rollover in links */
-a [class^="icon-"],
-a [class*=" icon-"],
-a [class^="icon-"]:before,
-a [class*=" icon-"]:before {
-  display: inline;
-}
-/* increased font size for icon-large */
-[class^="icon-"].icon-fixed-width,
-[class*=" icon-"].icon-fixed-width {
-  display: inline-block;
-  width: 1.2857142857142858em;
-  text-align: center;
-}
-[class^="icon-"].icon-fixed-width.icon-large,
-[class*=" icon-"].icon-fixed-width.icon-large {
-  width: 1.5714285714285714em;
-}
-ul.icons-ul {
-  list-style-type: none;
-  text-indent: -0.7142857142857143em;
-  margin-left: 2.142857142857143em;
-}
-ul.icons-ul > li .icon-li {
-  width: 0.7142857142857143em;
-  display: inline-block;
-  text-align: center;
-}
-[class^="icon-"].hide,
-[class*=" icon-"].hide {
-  display: none;
-}
-.icon-muted {
-  color: #eeeeee;
-}
-.icon-light {
-  color: #ffffff;
-}
-.icon-dark {
-  color: #333333;
-}
-.icon-border {
-  border: solid 1px #eeeeee;
-  padding: .2em .25em .15em;
-  -webkit-border-radius: 3px;
-  -moz-border-radius: 3px;
-  border-radius: 3px;
-}
-.icon-2x {
-  font-size: 2em;
-}
-.icon-2x.icon-border {
-  border-width: 2px;
-  -webkit-border-radius: 4px;
-  -moz-border-radius: 4px;
-  border-radius: 4px;
-}
-.icon-3x {
-  font-size: 3em;
-}
-.icon-3x.icon-border {
-  border-width: 3px;
-  -webkit-border-radius: 5px;
-  -moz-border-radius: 5px;
-  border-radius: 5px;
-}
-.icon-4x {
-  font-size: 4em;
-}
-.icon-4x.icon-border {
-  border-width: 4px;
-  -webkit-border-radius: 6px;
-  -moz-border-radius: 6px;
-  border-radius: 6px;
-}
-.icon-5x {
-  font-size: 5em;
-}
-.icon-5x.icon-border {
-  border-width: 5px;
-  -webkit-border-radius: 7px;
-  -moz-border-radius: 7px;
-  border-radius: 7px;
-}
-.pull-right {
-  float: right;
-}
-.pull-left {
-  float: left;
-}
-[class^="icon-"].pull-left,
-[class*=" icon-"].pull-left {
-  margin-right: .3em;
-}
-[class^="icon-"].pull-right,
-[class*=" icon-"].pull-right {
-  margin-left: .3em;
-}
-/* BOOTSTRAP SPECIFIC CLASSES
- * -------------------------- */
-/* Bootstrap 2.0 sprites.less reset */
-[class^="icon-"],
-[class*=" icon-"] {
-  display: inline;
-  width: auto;
-  height: auto;
-  line-height: normal;
-  vertical-align: baseline;
-  background-image: none;
-  background-position: 0% 0%;
-  background-repeat: repeat;
-  margin-top: 0;
-}
-/* more sprites.less reset */
-.icon-white,
-.nav-pills > .active > a > [class^="icon-"],
-.nav-pills > .active > a > [class*=" icon-"],
-.nav-list > .active > a > [class^="icon-"],
-.nav-list > .active > a > [class*=" icon-"],
-.navbar-inverse .nav > .active > a > [class^="icon-"],
-.navbar-inverse .nav > .active > a > [class*=" icon-"],
-.dropdown-menu > li > a:hover > [class^="icon-"],
-.dropdown-menu > li > a:hover > [class*=" icon-"],
-.dropdown-menu > .active > a > [class^="icon-"],
-.dropdown-menu > .active > a > [class*=" icon-"],
-.dropdown-submenu:hover > a > [class^="icon-"],
-.dropdown-submenu:hover > a > [class*=" icon-"] {
-  background-image: none;
-}
-/* keeps Bootstrap styles with and without icons the same */
-.btn [class^="icon-"].icon-large,
-.nav [class^="icon-"].icon-large,
-.btn [class*=" icon-"].icon-large,
-.nav [class*=" icon-"].icon-large {
-  line-height: .9em;
-}
-.btn [class^="icon-"].icon-spin,
-.nav [class^="icon-"].icon-spin,
-.btn [class*=" icon-"].icon-spin,
-.nav [class*=" icon-"].icon-spin {
-  display: inline-block;
-}
-.nav-tabs [class^="icon-"],
-.nav-pills [class^="icon-"],
-.nav-tabs [class*=" icon-"],
-.nav-pills [class*=" icon-"],
-.nav-tabs [class^="icon-"].icon-large,
-.nav-pills [class^="icon-"].icon-large,
-.nav-tabs [class*=" icon-"].icon-large,
-.nav-pills [class*=" icon-"].icon-large {
-  line-height: .9em;
-}
-.btn [class^="icon-"].pull-left.icon-2x,
-.btn [class*=" icon-"].pull-left.icon-2x,
-.btn [class^="icon-"].pull-right.icon-2x,
-.btn [class*=" icon-"].pull-right.icon-2x {
-  margin-top: .18em;
-}
-.btn [class^="icon-"].icon-spin.icon-large,
-.btn [class*=" icon-"].icon-spin.icon-large {
-  line-height: .8em;
-}
-.btn.btn-small [class^="icon-"].pull-left.icon-2x,
-.btn.btn-small [class*=" icon-"].pull-left.icon-2x,
-.btn.btn-small [class^="icon-"].pull-right.icon-2x,
-.btn.btn-small [class*=" icon-"].pull-right.icon-2x {
-  margin-top: .25em;
-}
-.btn.btn-large [class^="icon-"],
-.btn.btn-large [class*=" icon-"] {
-  margin-top: 0;
-}
-.btn.btn-large [class^="icon-"].pull-left.icon-2x,
-.btn.btn-large [class*=" icon-"].pull-left.icon-2x,
-.btn.btn-large [class^="icon-"].pull-right.icon-2x,
-.btn.btn-large [class*=" icon-"].pull-right.icon-2x {
-  margin-top: .05em;
-}
-.btn.btn-large [class^="icon-"].pull-left.icon-2x,
-.btn.btn-large [class*=" icon-"].pull-left.icon-2x {
-  margin-right: .2em;
-}
-.btn.btn-large [class^="icon-"].pull-right.icon-2x,
-.btn.btn-large [class*=" icon-"].pull-right.icon-2x {
-  margin-left: .2em;
-}
-/* EXTRAS
- * -------------------------- */
-/* Stacked and layered icon */
-.icon-stack {
-  position: relative;
-  display: inline-block;
-  width: 2em;
-  height: 2em;
-  line-height: 2em;
-  vertical-align: -35%;
-}
-.icon-stack [class^="icon-"],
-.icon-stack [class*=" icon-"] {
-  display: block;
-  text-align: center;
-  position: absolute;
-  width: 100%;
-  height: 100%;
-  font-size: 1em;
-  line-height: inherit;
-  *line-height: 2em;
-}
-.icon-stack .icon-stack-base {
-  font-size: 2em;
-  *line-height: 1em;
-}
-/* Animated rotating icon */
-.icon-spin {
-  display: inline-block;
-  -moz-animation: spin 2s infinite linear;
-  -o-animation: spin 2s infinite linear;
-  -webkit-animation: spin 2s infinite linear;
-  animation: spin 2s infinite linear;
-}
-@-moz-keyframes spin {
-  0% {
-    -moz-transform: rotate(0deg);
-  }
-  100% {
-    -moz-transform: rotate(359deg);
-  }
-}
-@-webkit-keyframes spin {
-  0% {
-    -webkit-transform: rotate(0deg);
-  }
-  100% {
-    -webkit-transform: rotate(359deg);
-  }
-}
-@-o-keyframes spin {
-  0% {
-    -o-transform: rotate(0deg);
-  }
-  100% {
-    -o-transform: rotate(359deg);
-  }
-}
-@-ms-keyframes spin {
-  0% {
-    -ms-transform: rotate(0deg);
-  }
-  100% {
-    -ms-transform: rotate(359deg);
-  }
-}
-@keyframes spin {
-  0% {
-    transform: rotate(0deg);
-  }
-  100% {
-    transform: rotate(359deg);
-  }
-}
-/* Icon rotations and mirroring */
-.icon-rotate-90:before {
-  -webkit-transform: rotate(90deg);
-  -moz-transform: rotate(90deg);
-  -ms-transform: rotate(90deg);
-  -o-transform: rotate(90deg);
-  transform: rotate(90deg);
-  filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=1);
-}
-.icon-rotate-180:before {
-  -webkit-transform: rotate(180deg);
-  -moz-transform: rotate(180deg);
-  -ms-transform: rotate(180deg);
-  -o-transform: rotate(180deg);
-  transform: rotate(180deg);
-  filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=2);
-}
-.icon-rotate-270:before {
-  -webkit-transform: rotate(270deg);
-  -moz-transform: rotate(270deg);
-  -ms-transform: rotate(270deg);
-  -o-transform: rotate(270deg);
-  transform: rotate(270deg);
-  filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=3);
-}
-.icon-flip-horizontal:before {
-  -webkit-transform: scale(-1, 1);
-  -moz-transform: scale(-1, 1);
-  -ms-transform: scale(-1, 1);
-  -o-transform: scale(-1, 1);
-  transform: scale(-1, 1);
-}
-.icon-flip-vertical:before {
-  -webkit-transform: scale(1, -1);
-  -moz-transform: scale(1, -1);
-  -ms-transform: scale(1, -1);
-  -o-transform: scale(1, -1);
-  transform: scale(1, -1);
-}
-/* Font Awesome uses the Unicode Private Use Area (PUA) to ensure screen
-   readers do not read off random characters that represent icons */
-.icon-glass:before {
-  content: "\f000";
-}
-.icon-music:before {
-  content: "\f001";
-}
-.icon-search:before {
-  content: "\f002";
-}
-.icon-envelope:before {
-  content: "\f003";
-}
-.icon-heart:before {
-  content: "\f004";
-}
-.icon-star:before {
-  content: "\f005";
-}
-.icon-star-empty:before {
-  content: "\f006";
-}
-.icon-user:before {
-  content: "\f007";
-}
-.icon-film:before {
-  content: "\f008";
-}
-.icon-th-large:before {
-  content: "\f009";
-}
-.icon-th:before {
-  content: "\f00a";
-}
-.icon-th-list:before {
-  content: "\f00b";
-}
-.icon-ok:before {
-  content: "\f00c";
-}
-.icon-remove:before {
-  content: "\f00d";
-}
-.icon-zoom-in:before {
-  content: "\f00e";
-}
-.icon-zoom-out:before {
-  content: "\f010";
-}
-.icon-off:before {
-  content: "\f011";
-}
-.icon-signal:before {
-  content: "\f012";
-}
-.icon-cog:before {
-  content: "\f013";
-}
-.icon-trash:before {
-  content: "\f014";
-}
-.icon-home:before {
-  content: "\f015";
-}
-.icon-file:before {
-  content: "\f016";
-}
-.icon-time:before {
-  content: "\f017";
-}
-.icon-road:before {
-  content: "\f018";
-}
-.icon-download-alt:before {
-  content: "\f019";
-}
-.icon-download:before {
-  content: "\f01a";
-}
-.icon-upload:before {
-  content: "\f01b";
-}
-.icon-inbox:before {
-  content: "\f01c";
-}
-.icon-play-circle:before {
-  content: "\f01d";
-}
-.icon-repeat:before,
-.icon-rotate-right:before {
-  content: "\f01e";
-}
-/* F020 doesn't work in Safari. all shifted one down */
-.icon-refresh:before {
-  content: "\f021";
-}
-.icon-list-alt:before {
-  content: "\f022";
-}
-.icon-lock:before {
-  content: "\f023";
-}
-.icon-flag:before {
-  content: "\f024";
-}
-.icon-headphones:before {
-  content: "\f025";
-}
-.icon-volume-off:before {
-  content: "\f026";
-}
-.icon-volume-down:before {
-  content: "\f027";
-}
-.icon-volume-up:before {
-  content: "\f028";
-}
-.icon-qrcode:before {
-  content: "\f029";
-}
-.icon-barcode:before {
-  content: "\f02a";
-}
-.icon-tag:before {
-  content: "\f02b";
-}
-.icon-tags:before {
-  content: "\f02c";
-}
-.icon-book:before {
-  content: "\f02d";
-}
-.icon-bookmark:before {
-  content: "\f02e";
-}
-.icon-print:before {
-  content: "\f02f";
-}
-.icon-camera:before {
-  content: "\f030";
-}
-.icon-font:before {
-  content: "\f031";
-}
-.icon-bold:before {
-  content: "\f032";
-}
-.icon-italic:before {
-  content: "\f033";
-}
-.icon-text-height:before {
-  content: "\f034";
-}
-.icon-text-width:before {
-  content: "\f035";
-}
-.icon-align-left:before {
-  content: "\f036";
-}
-.icon-align-center:before {
-  content: "\f037";
-}
-.icon-align-right:before {
-  content: "\f038";
-}
-.icon-align-justify:before {
-  content: "\f039";
-}
-.icon-list:before {
-  content: "\f03a";
-}
-.icon-indent-left:before {
-  content: "\f03b";
-}
-.icon-indent-right:before {
-  content: "\f03c";
-}
-.icon-facetime-video:before {
-  content: "\f03d";
-}
-.icon-picture:before {
-  content: "\f03e";
-}
-.icon-pencil:before {
-  content: "\f040";
-}
-.icon-map-marker:before {
-  content: "\f041";
-}
-.icon-adjust:before {
-  content: "\f042";
-}
-.icon-tint:before {
-  content: "\f043";
-}
-.icon-edit:before {
-  content: "\f044";
-}
-.icon-share:before {
-  content: "\f045";
-}
-.icon-check:before {
-  content: "\f046";
-}
-.icon-move:before {
-  content: "\f047";
-}
-.icon-step-backward:before {
-  content: "\f048";
-}
-.icon-fast-backward:before {
-  content: "\f049";
-}
-.icon-backward:before {
-  content: "\f04a";
-}
-.icon-play:before {
-  content: "\f04b";
-}
-.icon-pause:before {
-  content: "\f04c";
-}
-.icon-stop:before {
-  content: "\f04d";
-}
-.icon-forward:before {
-  content: "\f04e";
-}
-.icon-fast-forward:before {
-  content: "\f050";
-}
-.icon-step-forward:before {
-  content: "\f051";
-}
-.icon-eject:before {
-  content: "\f052";
-}
-.icon-chevron-left:before {
-  content: "\f053";
-}
-.icon-chevron-right:before {
-  content: "\f054";
-}
-.icon-plus-sign:before {
-  content: "\f055";
-}
-.icon-minus-sign:before {
-  content: "\f056";
-}
-.icon-remove-sign:before {
-  content: "\f057";
-}
-.icon-ok-sign:before {
-  content: "\f058";
-}
-.icon-question-sign:before {
-  content: "\f059";
-}
-.icon-info-sign:before {
-  content: "\f05a";
-}
-.icon-screenshot:before {
-  content: "\f05b";
-}
-.icon-remove-circle:before {
-  content: "\f05c";
-}
-.icon-ok-circle:before {
-  content: "\f05d";
-}
-.icon-ban-circle:before {
-  content: "\f05e";
-}
-.icon-arrow-left:before {
-  content: "\f060";
-}
-.icon-arrow-right:before {
-  content: "\f061";
-}
-.icon-arrow-up:before {
-  content: "\f062";
-}
-.icon-arrow-down:before {
-  content: "\f063";
-}
-.icon-share-alt:before,
-.icon-mail-forward:before {
-  content: "\f064";
-}
-.icon-resize-full:before {
-  content: "\f065";
-}
-.icon-resize-small:before {
-  content: "\f066";
-}
-.icon-plus:before {
-  content: "\f067";
-}
-.icon-minus:before {
-  content: "\f068";
-}
-.icon-asterisk:before {
-  content: "\f069";
-}
-.icon-exclamation-sign:before {
-  content: "\f06a";
-}
-.icon-gift:before {
-  content: "\f06b";
-}
-.icon-leaf:before {
-  content: "\f06c";
-}
-.icon-fire:before {
-  content: "\f06d";
-}
-.icon-eye-open:before {
-  content: "\f06e";
-}
-.icon-eye-close:before {
-  content: "\f070";
-}
-.icon-warning-sign:before {
-  content: "\f071";
-}
-.icon-plane:before {
-  content: "\f072";
-}
-.icon-calendar:before {
-  content: "\f073";
-}
-.icon-random:before {
-  content: "\f074";
-}
-.icon-comment:before {
-  content: "\f075";
-}
-.icon-magnet:before {
-  content: "\f076";
-}
-.icon-chevron-up:before {
-  content: "\f077";
-}
-.icon-chevron-down:before {
-  content: "\f078";
-}
-.icon-retweet:before {
-  content: "\f079";
-}
-.icon-shopping-cart:before {
-  content: "\f07a";
-}
-.icon-folder-close:before {
-  content: "\f07b";
-}
-.icon-folder-open:before {
-  content: "\f07c";
-}
-.icon-resize-vertical:before {
-  content: "\f07d";
-}
-.icon-resize-horizontal:before {
-  content: "\f07e";
-}
-.icon-bar-chart:before {
-  content: "\f080";
-}
-.icon-twitter-sign:before {
-  content: "\f081";
-}
-.icon-facebook-sign:before {
-  content: "\f082";
-}
-.icon-camera-retro:before {
-  content: "\f083";
-}
-.icon-key:before {
-  content: "\f084";
-}
-.icon-cogs:before {
-  content: "\f085";
-}
-.icon-comments:before {
-  content: "\f086";
-}
-.icon-thumbs-up:before {
-  content: "\f087";
-}
-.icon-thumbs-down:before {
-  content: "\f088";
-}
-.icon-star-half:before {
-  content: "\f089";
-}
-.icon-heart-empty:before {
-  content: "\f08a";
-}
-.icon-signout:before {
-  content: "\f08b";
-}
-.icon-linkedin-sign:before {
-  content: "\f08c";
-}
-.icon-pushpin:before {
-  content: "\f08d";
-}
-.icon-external-link:before {
-  content: "\f08e";
-}
-.icon-signin:before {
-  content: "\f090";
-}
-.icon-trophy:before {
-  content: "\f091";
-}
-.icon-github-sign:before {
-  content: "\f092";
-}
-.icon-upload-alt:before {
-  content: "\f093";
-}
-.icon-lemon:before {
-  content: "\f094";
-}
-.icon-phone:before {
-  content: "\f095";
-}
-.icon-check-empty:before {
-  content: "\f096";
-}
-.icon-bookmark-empty:before {
-  content: "\f097";
-}
-.icon-phone-sign:before {
-  content: "\f098";
-}
-.icon-twitter:before {
-  content: "\f099";
-}
-.icon-facebook:before {
-  content: "\f09a";
-}
-.icon-github:before {
-  content: "\f09b";
-}
-.icon-unlock:before {
-  content: "\f09c";
-}
-.icon-credit-card:before {
-  content: "\f09d";
-}
-.icon-rss:before {
-  content: "\f09e";
-}
-.icon-hdd:before {
-  content: "\f0a0";
-}
-.icon-bullhorn:before {
-  content: "\f0a1";
-}
-.icon-bell:before {
-  content: "\f0a2";
-}
-.icon-certificate:before {
-  content: "\f0a3";
-}
-.icon-hand-right:before {
-  content: "\f0a4";
-}
-.icon-hand-left:before {
-  content: "\f0a5";
-}
-.icon-hand-up:before {
-  content: "\f0a6";
-}
-.icon-hand-down:before {
-  content: "\f0a7";
-}
-.icon-circle-arrow-left:before {
-  content: "\f0a8";
-}
-.icon-circle-arrow-right:before {
-  content: "\f0a9";
-}
-.icon-circle-arrow-up:before {
-  content: "\f0aa";
-}
-.icon-circle-arrow-down:before {
-  content: "\f0ab";
-}
-.icon-globe:before {
-  content: "\f0ac";
-}
-.icon-wrench:before {
-  content: "\f0ad";
-}
-.icon-tasks:before {
-  content: "\f0ae";
-}
-.icon-filter:before {
-  content: "\f0b0";
-}
-.icon-briefcase:before {
-  content: "\f0b1";
-}
-.icon-fullscreen:before {
-  content: "\f0b2";
-}
-.icon-group:before {
-  content: "\f0c0";
-}
-.icon-link:before {
-  content: "\f0c1";
-}
-.icon-cloud:before {
-  content: "\f0c2";
-}
-.icon-beaker:before {
-  content: "\f0c3";
-}
-.icon-cut:before {
-  content: "\f0c4";
-}
-.icon-copy:before {
-  content: "\f0c5";
-}
-.icon-paper-clip:before {
-  content: "\f0c6";
-}
-.icon-save:before {
-  content: "\f0c7";
-}
-.icon-sign-blank:before {
-  content: "\f0c8";
-}
-.icon-reorder:before {
-  content: "\f0c9";
-}
-.icon-list-ul:before {
-  content: "\f0ca";
-}
-.icon-list-ol:before {
-  content: "\f0cb";
-}
-.icon-strikethrough:before {
-  content: "\f0cc";
-}
-.icon-underline:before {
-  content: "\f0cd";
-}
-.icon-table:before {
-  content: "\f0ce";
-}
-.icon-magic:before {
-  content: "\f0d0";
-}
-.icon-truck:before {
-  content: "\f0d1";
-}
-.icon-pinterest:before {
-  content: "\f0d2";
-}
-.icon-pinterest-sign:before {
-  content: "\f0d3";
-}
-.icon-google-plus-sign:before {
-  content: "\f0d4";
-}
-.icon-google-plus:before {
-  content: "\f0d5";
-}
-.icon-money:before {
-  content: "\f0d6";
-}
-.icon-caret-down:before {
-  content: "\f0d7";
-}
-.icon-caret-up:before {
-  content: "\f0d8";
-}
-.icon-caret-left:before {
-  content: "\f0d9";
-}
-.icon-caret-right:before {
-  content: "\f0da";
-}
-.icon-columns:before {
-  content: "\f0db";
-}
-.icon-sort:before {
-  content: "\f0dc";
-}
-.icon-sort-down:before {
-  content: "\f0dd";
-}
-.icon-sort-up:before {
-  content: "\f0de";
-}
-.icon-envelope-alt:before {
-  content: "\f0e0";
-}
-.icon-linkedin:before {
-  content: "\f0e1";
-}
-.icon-undo:before,
-.icon-rotate-left:before {
-  content: "\f0e2";
-}
-.icon-legal:before {
-  content: "\f0e3";
-}
-.icon-dashboard:before {
-  content: "\f0e4";
-}
-.icon-comment-alt:before {
-  content: "\f0e5";
-}
-.icon-comments-alt:before {
-  content: "\f0e6";
-}
-.icon-bolt:before {
-  content: "\f0e7";
-}
-.icon-sitemap:before {
-  content: "\f0e8";
-}
-.icon-umbrella:before {
-  content: "\f0e9";
-}
-.icon-paste:before {
-  content: "\f0ea";
-}
-.icon-lightbulb:before {
-  content: "\f0eb";
-}
-.icon-exchange:before {
-  content: "\f0ec";
-}
-.icon-cloud-download:before {
-  content: "\f0ed";
-}
-.icon-cloud-upload:before {
-  content: "\f0ee";
-}
-.icon-user-md:before {
-  content: "\f0f0";
-}
-.icon-stethoscope:before {
-  content: "\f0f1";
-}
-.icon-suitcase:before {
-  content: "\f0f2";
-}
-.icon-bell-alt:before {
-  content: "\f0f3";
-}
-.icon-coffee:before {
-  content: "\f0f4";
-}
-.icon-food:before {
-  content: "\f0f5";
-}
-.icon-file-alt:before {
-  content: "\f0f6";
-}
-.icon-building:before {
-  content: "\f0f7";
-}
-.icon-hospital:before {
-  content: "\f0f8";
-}
-.icon-ambulance:before {
-  content: "\f0f9";
-}
-.icon-medkit:before {
-  content: "\f0fa";
-}
-.icon-fighter-jet:before {
-  content: "\f0fb";
-}
-.icon-beer:before {
-  content: "\f0fc";
-}
-.icon-h-sign:before {
-  content: "\f0fd";
-}
-.icon-plus-sign-alt:before {
-  content: "\f0fe";
-}
-.icon-double-angle-left:before {
-  content: "\f100";
-}
-.icon-double-angle-right:before {
-  content: "\f101";
-}
-.icon-double-angle-up:before {
-  content: "\f102";
-}
-.icon-double-angle-down:before {
-  content: "\f103";
-}
-.icon-angle-left:before {
-  content: "\f104";
-}
-.icon-angle-right:before {
-  content: "\f105";
-}
-.icon-angle-up:before {
-  content: "\f106";
-}
-.icon-angle-down:before {
-  content: "\f107";
-}
-.icon-desktop:before {
-  content: "\f108";
-}
-.icon-laptop:before {
-  content: "\f109";
-}
-.icon-tablet:before {
-  content: "\f10a";
-}
-.icon-mobile-phone:before {
-  content: "\f10b";
-}
-.icon-circle-blank:before {
-  content: "\f10c";
-}
-.icon-quote-left:before {
-  content: "\f10d";
-}
-.icon-quote-right:before {
-  content: "\f10e";
-}
-.icon-spinner:before {
-  content: "\f110";
-}
-.icon-circle:before {
-  content: "\f111";
-}
-.icon-reply:before,
-.icon-mail-reply:before {
-  content: "\f112";
-}
-.icon-folder-close-alt:before {
-  content: "\f114";
-}
-.icon-folder-open-alt:before {
-  content: "\f115";
-}
-.icon-expand-alt:before {
-  content: "\f116";
-}
-.icon-collapse-alt:before {
-  content: "\f117";
-}
-.icon-smile:before {
-  content: "\f118";
-}
-.icon-frown:before {
-  content: "\f119";
-}
-.icon-meh:before {
-  content: "\f11a";
-}
-.icon-gamepad:before {
-  content: "\f11b";
-}
-.icon-keyboard:before {
-  content: "\f11c";
-}
-.icon-flag-alt:before {
-  content: "\f11d";
-}
-.icon-flag-checkered:before {
-  content: "\f11e";
-}
-.icon-terminal:before {
-  content: "\f120";
-}
-.icon-code:before {
-  content: "\f121";
-}
-.icon-reply-all:before {
-  content: "\f122";
-}
-.icon-mail-reply-all:before {
-  content: "\f122";
-}
-.icon-star-half-full:before,
-.icon-star-half-empty:before {
-  content: "\f123";
-}
-.icon-location-arrow:before {
-  content: "\f124";
-}
-.icon-crop:before {
-  content: "\f125";
-}
-.icon-code-fork:before {
-  content: "\f126";
-}
-.icon-unlink:before {
-  content: "\f127";
-}
-.icon-question:before {
-  content: "\f128";
-}
-.icon-info:before {
-  content: "\f129";
-}
-.icon-exclamation:before {
-  content: "\f12a";
-}
-.icon-superscript:before {
-  content: "\f12b";
-}
-.icon-subscript:before {
-  content: "\f12c";
-}
-.icon-eraser:before {
-  content: "\f12d";
-}
-.icon-puzzle-piece:before {
-  content: "\f12e";
-}
-.icon-microphone:before {
-  content: "\f130";
-}
-.icon-microphone-off:before {
-  content: "\f131";
-}
-.icon-shield:before {
-  content: "\f132";
-}
-.icon-calendar-empty:before {
-  content: "\f133";
-}
-.icon-fire-extinguisher:before {
-  content: "\f134";
-}
-.icon-rocket:before {
-  content: "\f135";
-}
-.icon-maxcdn:before {
-  content: "\f136";
-}
-.icon-chevron-sign-left:before {
-  content: "\f137";
-}
-.icon-chevron-sign-right:before {
-  content: "\f138";
-}
-.icon-chevron-sign-up:before {
-  content: "\f139";
-}
-.icon-chevron-sign-down:before {
-  content: "\f13a";
-}
-.icon-html5:before {
-  content: "\f13b";
-}
-.icon-css3:before {
-  content: "\f13c";
-}
-.icon-anchor:before {
-  content: "\f13d";
-}
-.icon-unlock-alt:before {
-  content: "\f13e";
-}
-.icon-bullseye:before {
-  content: "\f140";
-}
-.icon-ellipsis-horizontal:before {
-  content: "\f141";
-}
-.icon-ellipsis-vertical:before {
-  content: "\f142";
-}
-.icon-rss-sign:before {
-  content: "\f143";
-}
-.icon-play-sign:before {
-  content: "\f144";
-}
-.icon-ticket:before {
-  content: "\f145";
-}
-.icon-minus-sign-alt:before {
-  content: "\f146";
-}
-.icon-check-minus:before {
-  content: "\f147";
-}
-.icon-level-up:before {
-  content: "\f148";
-}
-.icon-level-down:before {
-  content: "\f149";
-}
-.icon-check-sign:before {
-  content: "\f14a";
-}
-.icon-edit-sign:before {
-  content: "\f14b";
-}
-.icon-external-link-sign:before {
-  content: "\f14c";
-}
-.icon-share-sign:before {
-  content: "\f14d";
-}
diff --git a/lms/static/sass/views/_verification.scss b/lms/static/sass/views/_verification.scss
index 4aa5f88e8b97..8d0ea210ca64 100644
--- a/lms/static/sass/views/_verification.scss
+++ b/lms/static/sass/views/_verification.scss
@@ -1,95 +1,7 @@
 // lms - views - verification flow
 // ====================
 
-// MISC: extends - type
-// application: canned headings
-%hd-lv1 {
-  @extend %t-title1;
-  @extend %t-weight1;
-  color: $m-gray-d4;
-  margin: 0 0 ($baseline*2) 0;
-}
-
-%hd-lv2 {
-  @extend %t-title4;
-  @extend %t-weight1;
-  margin: 0 0 ($baseline*0.75) 0;
-  border-bottom: 1px solid $m-gray-l3;
-  padding-bottom: ($baseline/2);
-  color: $m-gray-d4;
-}
-
-%hd-lv3 {
-  @extend %t-title6;
-  @extend %t-weight4;
-  margin: 0 0 ($baseline/4) 0;
-  color: $m-gray-d4;
-}
-
-%hd-lv4 {
-  @extend %t-title6;
-  @extend %t-weight2;
-  margin: 0 0 $baseline 0;
-  color: $m-gray-d4;
-}
-
-%hd-lv5 {
-  @extend %t-title7;
-  @extend %t-weight4;
-  margin: 0 0 ($baseline/4) 0;
-  color: $m-gray-d4;
-}
-
-// application: canned copy
-%copy-base {
-  @extend %t-copy-base;
-  color: $m-gray-d2;
-}
-
-%copy-lead1 {
-  @extend %t-copy-lead2;
-  color: $m-gray;
-}
-
-%copy-detail {
-  @extend %t-copy-sub1;
-  @extend %t-weight3;
-  color: $m-gray-d1;
-}
-
-%copy-metadata {
-  @extend %t-copy-sub2;
-  color: $m-gray-d1;
-
-
-  %copy-metadata-value {
-    @extend %t-weight2;
-  }
-
-  %copy-metadata-value {
-    @extend %t-weight4;
-  }
-}
-
-// application: canned links
-%copy-link {
-  border-bottom: 1px dotted transparent;
-
-  &:hover, &:active {
-    border-color: $link-color-d1;
-  }
-}
-
-%copy-badge {
-  @extend %t-title8;
-  @extend %t-weight5;
-  border-radius: ($baseline/5);
-  padding: ($baseline/2) $baseline;
-  text-transform: uppercase;
-}
-
-// ====================
-
+// MISC: extends - button
 %btn-verify-primary {
   @extend %btn-primary-green;
 }
diff --git a/lms/templates/courseware/courseware-error.html b/lms/templates/courseware/courseware-error.html
index f0f7969026de..9018495bff7e 100644
--- a/lms/templates/courseware/courseware-error.html
+++ b/lms/templates/courseware/courseware-error.html
@@ -6,7 +6,8 @@
 <%block name="title"><title>${_("Courseware")} - ${settings.PLATFORM_NAME}</title></%block>
 
 <%block name="headextra">
-  <%static:css group='course'/>
+<%static:css group='style-course-vendor'/>
+<%static:css group='style-course'/>
 </%block>
 
 <%include file="/courseware/course_navigation.html" args="active_page='courseware'" />
diff --git a/lms/templates/courseware/courseware.html b/lms/templates/courseware/courseware.html
index 2a52b50b0971..3f5c1d8c004d 100644
--- a/lms/templates/courseware/courseware.html
+++ b/lms/templates/courseware/courseware.html
@@ -5,8 +5,11 @@
 <%block name="title"><title>${_("{course_number} Courseware").format(course_number=course.display_number_with_default) | h}</title></%block>
 
 <%block name="headextra">
-  <%static:css group='course'/>
-  <%include file="../discussion/_js_head_dependencies.html" />
+<%static:css group='style-course-vendor'/>
+<%static:css group='style-course'/>
+
+<%include file="../discussion/_js_head_dependencies.html" />
+
   % if show_chat:
     <link rel="stylesheet" href="${static.url('css/vendor/ui-lightness/jquery-ui-1.8.22.custom.css')}" />
     ## It'd be better to have this in a place like lms/css/vendor/candy,
diff --git a/lms/templates/courseware/gradebook.html b/lms/templates/courseware/gradebook.html
index 2c9f3e847474..8828721555de 100644
--- a/lms/templates/courseware/gradebook.html
+++ b/lms/templates/courseware/gradebook.html
@@ -11,7 +11,8 @@
 </%block>
 
 <%block name="headextra">
-  <%static:css group='course'/>
+<%static:css group='style-course-vendor'/>
+<%static:css group='style-course'/>
 
   <style type="text/css">
   % for (grade, _), color in zip(ordered_grades, ['green', 'Chocolate']):
diff --git a/lms/templates/courseware/info.html b/lms/templates/courseware/info.html
index a1aad363a929..5c2220010acf 100644
--- a/lms/templates/courseware/info.html
+++ b/lms/templates/courseware/info.html
@@ -4,7 +4,8 @@
 <%namespace name='static' file='/static_content.html'/>
 
 <%block name="headextra">
-  <%static:css group='course'/>
+<%static:css group='style-course-vendor'/>
+<%static:css group='style-course'/>
 </%block>
 
 <%block name="title"><title>${_("{course.display_number_with_default} Course Info").format(course=course) | h}</title></%block>
diff --git a/lms/templates/courseware/instructor_dashboard.html b/lms/templates/courseware/instructor_dashboard.html
index 7b06d8e309f5..f0c9475c4888 100644
--- a/lms/templates/courseware/instructor_dashboard.html
+++ b/lms/templates/courseware/instructor_dashboard.html
@@ -4,7 +4,9 @@
 <%namespace name='static' file='/static_content.html'/>
 
 <%block name="headextra">
-  <%static:css group='course'/>
+<%static:css group='style-course-vendor'/>
+<%static:css group='style-course'/>
+
   <script type="text/javascript" src="${static.url('js/vendor/flot/jquery.flot.js')}"></script>
   <script type="text/javascript" src="${static.url('js/vendor/flot/jquery.flot.axislabels.js')}"></script>
   <script type="text/javascript" src="${static.url('js/vendor/jquery-jvectormap-1.1.1/jquery-jvectormap-1.1.1.min.js')}"></script>
@@ -369,7 +371,8 @@ <h2>${_("Student-specific grade inspection and adjustment")}</h2>
 %if modeflag.get('Enrollment'):
 
     <hr width="40%" style="align:left">
-    <p>
+    <h2>${_("Enrollment Data")}</h2>
+
     <input type="submit" name="action" value="List enrolled students">
     <input type="submit" name="action" value="List students who may enroll but may not have yet signed up">
     <hr width="40%" style="align:left">
@@ -506,6 +509,13 @@ <h2>${_("Student-specific grade inspection and adjustment")}</h2>
         return true;
       }
     </script>
+
+    <p>These email actions run in the background, and status for active email tasks will appear in a table below.
+       To see status for all bulk email tasks submitted for this course, click on this button:
+    </p>
+    <p>
+      <input type="submit" name="action" value="Show Background Email Task History">
+    </p>
 %endif
 
     </form>
diff --git a/lms/templates/courseware/news.html b/lms/templates/courseware/news.html
index 1ecb4439d735..c56319b4f77d 100644
--- a/lms/templates/courseware/news.html
+++ b/lms/templates/courseware/news.html
@@ -5,7 +5,8 @@
 <%block name="title"><title>${_("News - MITx 6.002x")}</title></%block>
 
 <%block name="headextra">
-<%static:css group='course'/>
+<%static:css group='style-course-vendor'/>
+<%static:css group='style-course'/>
 </%block>
 
 <%block name="js_extra">
diff --git a/lms/templates/courseware/progress.html b/lms/templates/courseware/progress.html
index 530ab39cd74f..1c099119c0cd 100644
--- a/lms/templates/courseware/progress.html
+++ b/lms/templates/courseware/progress.html
@@ -3,7 +3,8 @@
 <%namespace name='static' file='/static_content.html'/>
 
 <%block name="headextra">
-  <%static:css group='course'/>
+<%static:css group='style-course-vendor'/>
+<%static:css group='style-course'/>
 </%block>
 
 <%namespace name="progress_graph" file="/courseware/progress_graph.js"/>
diff --git a/lms/templates/courseware/static_tab.html b/lms/templates/courseware/static_tab.html
index f03dcacb8049..464aec0bca52 100644
--- a/lms/templates/courseware/static_tab.html
+++ b/lms/templates/courseware/static_tab.html
@@ -3,7 +3,8 @@
 <%namespace name='static' file='/static_content.html'/>
 
 <%block name="headextra">
-  <%static:css group='course'/>
+<%static:css group='style-course-vendor'/>
+<%static:css group='style-course'/>
 </%block>
 
 <%block name="title"><title>${course.display_number_with_default | h} ${tab['name']}</title></%block>
diff --git a/lms/templates/courseware/syllabus.html b/lms/templates/courseware/syllabus.html
index e2f3c5373984..d26fd259f731 100644
--- a/lms/templates/courseware/syllabus.html
+++ b/lms/templates/courseware/syllabus.html
@@ -3,7 +3,8 @@
 <%namespace name='static' file='/static_content.html'/>
 
 <%block name="headextra">
-  <%static:css group='course'/>
+<%static:css group='style-course-vendor'/>
+<%static:css group='style-course'/>
 </%block>
 
 <%block name="title"><title>${_("{course.display_number_with_default} Course Info").format(course=course) | h}</title></%block>
diff --git a/lms/templates/discussion/index.html b/lms/templates/discussion/index.html
index de5343379034..04e367c8b972 100644
--- a/lms/templates/discussion/index.html
+++ b/lms/templates/discussion/index.html
@@ -9,8 +9,10 @@
 <%block name="title"><title>${_("Discussion - {course_number}").format(course_number=course.display_number_with_default) | h}</title></%block>
 
 <%block name="headextra">
-<%static:css group='course'/>
-<%include file="_js_head_dependencies.html" />	
+<%static:css group='style-course-vendor'/>
+<%static:css group='style-course'/>
+
+<%include file="_js_head_dependencies.html" />
 </%block>
 
 <%block name="js_extra">
@@ -28,7 +30,7 @@
         <div class="discussion-column">
         </div>
     </div>
-</section> 
+</section>
 
 <%include file="_underscore_templates.html" />
 <%include file="_thread_list_template.html" />
diff --git a/lms/templates/discussion/single_thread.html b/lms/templates/discussion/single_thread.html
index 5bd6c6ca0313..c7723c8d5034 100644
--- a/lms/templates/discussion/single_thread.html
+++ b/lms/templates/discussion/single_thread.html
@@ -10,7 +10,9 @@
 <%block name="title"><title>${_("Discussion - {course_number}").format(course_number=course.display_number_with_default) | h}</title></%block>
 
 <%block name="headextra">
-<%static:css group='course'/>
+<%static:css group='style-course-vendor'/>
+<%static:css group='style-course'/>
+
 <%include file="_js_head_dependencies.html" />
 </%block>
 
diff --git a/lms/templates/discussion/user_profile.html b/lms/templates/discussion/user_profile.html
index 96e6fc20b931..53ff77a78b3d 100644
--- a/lms/templates/discussion/user_profile.html
+++ b/lms/templates/discussion/user_profile.html
@@ -7,7 +7,9 @@
 <%block name="title"><title>${_("Discussion - {course_number}").format(course_number=course.display_number_with_default) | h}</title></%block>
 
 <%block name="headextra">
-<%static:css group='course'/>
+<%static:css group='style-course-vendor'/>
+<%static:css group='style-course'/>
+
 <%include file="_js_head_dependencies.html" />
 </%block>
 
diff --git a/lms/templates/instructor/hint_manager.html b/lms/templates/instructor/hint_manager.html
index 4a6e219560f2..bedfd4add61e 100644
--- a/lms/templates/instructor/hint_manager.html
+++ b/lms/templates/instructor/hint_manager.html
@@ -4,7 +4,9 @@
 
 
 <%block name="headextra">
-  <%static:css group='course'/>
+  <%static:css group='style-course-vendor'/>
+  <%static:css group='style-course'/>
+
   <script type="text/javascript" src="${static.url('js/vendor/flot/jquery.flot.js')}"></script>
   <script type="text/javascript" src="${static.url('js/vendor/flot/jquery.flot.axislabels.js')}"></script>
   <script type="text/javascript" src="${static.url('js/vendor/jquery-jvectormap-1.1.1/jquery-jvectormap-1.1.1.min.js')}"></script>
@@ -25,14 +27,14 @@
             var i = 1
             $(".hint-select").each(function(){
                 if ($(this).is(":checked")) {
-                    data_dict[i] = [$(this).parent().attr("data-problem"), 
-                                    $(this).parent().attr("data-answer"), 
+                    data_dict[i] = [$(this).parent().attr("data-problem"),
+                                    $(this).parent().attr("data-answer"),
                                     $(this).parent().attr("data-pk")];
                     i += 1
                 }
             });
             $.ajax(window.location.pathname, {
-                type: "POST", 
+                type: "POST",
                 data: data_dict,
                 success: update_contents
             });
@@ -42,16 +44,16 @@
             var data_dict = {'op': 'change votes',
                              'field': field}
             for (var i=0; i<changed_votes.length; i++) {
-                data_dict[i] = [$(changed_votes[i]).parent().attr("data-problem"), 
-                                $(changed_votes[i]).parent().attr("data-answer"), 
+                data_dict[i] = [$(changed_votes[i]).parent().attr("data-problem"),
+                                $(changed_votes[i]).parent().attr("data-answer"),
                                 $(changed_votes[i]).parent().attr("data-pk"),
                                 $(changed_votes[i]).val()];
             }
             $.ajax(window.location.pathname, {
-                type: "POST", 
+                type: "POST",
                 data: data_dict,
                 success: update_contents
-            });        
+            });
         });
 
         $("#switch-fields").click(function(){
@@ -61,7 +63,7 @@
                 type: "POST",
                 data: out_dict,
                 success: update_contents
-              
+
               });
         });
 
@@ -87,14 +89,14 @@
             var i = 1
             $(".hint-select").each(function(){
                 if ($(this).is(":checked")) {
-                    data_dict[i] = [$(this).parent().attr("data-problem"), 
-                                    $(this).parent().attr("data-answer"), 
+                    data_dict[i] = [$(this).parent().attr("data-problem"),
+                                    $(this).parent().attr("data-answer"),
                                     $(this).parent().attr("data-pk")];
                     i += 1
                 }
             });
             $.ajax(window.location.pathname, {
-                type: "POST", 
+                type: "POST",
                 data: data_dict,
                 success: update_contents
             });
@@ -102,7 +104,7 @@
     }
 
     $(document).ready(setup);
-    
+
     function update_contents(data, status, jqXHR) {
         $('.instructor-dashboard-content').html(data.contents);
         setup();
diff --git a/lms/templates/instructor/instructor_dashboard_2/instructor_dashboard_2.html b/lms/templates/instructor/instructor_dashboard_2/instructor_dashboard_2.html
index c209db0103b8..30cf48f5057f 100644
--- a/lms/templates/instructor/instructor_dashboard_2/instructor_dashboard_2.html
+++ b/lms/templates/instructor/instructor_dashboard_2/instructor_dashboard_2.html
@@ -17,7 +17,8 @@
 ## 6. And tests go in lms/djangoapps/instructor/tests/
 
 <%block name="headextra">
-  <%static:css group='course'/>
+  <%static:css group='style-course-vendor'/>
+  <%static:css group='style-course'/>
   <script type="text/javascript" src="${static.url('js/vendor/underscore-min.js')}"></script>
   <script type="text/javascript" src="${static.url('js/vendor/mustache.js')}"></script>
   <script type="text/javascript" src="${static.url('js/vendor/flot/jquery.flot.js')}"></script>
@@ -31,6 +32,12 @@
   <script type="text/javascript" src="${static.url('js/vendor/slick.grid.js')}"></script>
   <link rel="stylesheet" href="${static.url('css/vendor/slickgrid/smoothness/jquery-ui-1.8.16.custom.css')}">
   <link rel="stylesheet" href="${static.url('css/vendor/slickgrid/slick.grid.css')}">
+  <script type="text/javascript" src="${static.url('js/vendor/CodeMirror/htmlmixed.js')}"></script>
+  <script type="text/javascript" src="${static.url('js/vendor/CodeMirror/css.js')}"></script>
+  <script type="text/javascript" src="${static.url('js/vendor/codemirror-compressed.js')}"></script>
+  <script type="text/javascript" src="${static.url('js/vendor/tiny_mce/tiny_mce.js')}"></script>
+  <script type="text/javascript" src="${static.url('js/vendor/tiny_mce/jquery.tinymce.js')}"></script>
+  <%static:js group='module-descriptor-js'/>
 </%block>
 
 ## NOTE that instructor is set as the active page so that the instructor button lights up, even though this is the instructor_2 page.
diff --git a/lms/templates/instructor/instructor_dashboard_2/send_email.html b/lms/templates/instructor/instructor_dashboard_2/send_email.html
new file mode 100644
index 000000000000..0c7354912a1f
--- /dev/null
+++ b/lms/templates/instructor/instructor_dashboard_2/send_email.html
@@ -0,0 +1,46 @@
+<%! from django.utils.translation import ugettext as _ %>
+<%page args="section_data"/>
+
+<div class="vert-left send-email" id="section-send-email">
+  <h2> ${_("Send Email")} </h2>
+  <div class="request-response msg msg-confirm copy" id="request-response"></div>
+  <ul class="list-fields">
+    <li class="field">
+      <label for="id_to">${_("Send to:")}</label><br/>
+      <select id="id_to" name="send_to">
+        <option value="myself">${_("Myself")}</option>
+        %if to_option == "staff":
+        <option value="staff" selected="selected">${_("Staff and instructors")}</option>
+        %else:
+        <option value="staff">${_("Staff and instructors")}</option>
+          %endif
+          %if to_option == "all":
+            <option value="all" selected="selected">${_("All (students, staff and instructors)")}</option>
+          %else:
+      <option value="all">${_("All (students, staff and instructors)")}</option>
+      %endif
+      </select>
+    </li>
+  <br/>
+  <li class="field">
+    <label for="id_subject">${_("Subject: ")}</label><br/>
+    <input type="text" id="id_subject" name="subject">
+  </li>
+  <li class="field">
+    <label>Message:</label>
+      <div class="email-editor"> 
+      ${ section_data['editor'] } 
+      </div>
+    <input type="hidden" name="message" value="">
+  </li>
+  </ul>
+ <div class="submit-email-action">
+  ${_("Please try not to email students more than once a day. Before sending your email, consider:")}
+  <ul class="list-advice">
+   <li class="item">${_("Have you read over the email to make sure it says everything you want to say?")}</li>
+   <li class="item">${_("Have you sent the email to yourself first to make sure you're happy with how it's displayed?")}</li>
+  </ul>
+ </div>
+  <input type="button" name="send" value="${_("Send Email")}" data-endpoint="${ section_data['send_email'] }" >
+  <div class="request-response-error"></div>
+</div>
diff --git a/lms/templates/instructor/staff_grading.html b/lms/templates/instructor/staff_grading.html
index 67f5aca04756..5b23f83e50c1 100644
--- a/lms/templates/instructor/staff_grading.html
+++ b/lms/templates/instructor/staff_grading.html
@@ -4,7 +4,8 @@
 <%namespace name='static' file='/static_content.html'/>
 
 <%block name="headextra">
-  <%static:css group='course'/>
+<%static:css group='style-course-vendor'/>
+<%static:css group='style-course'/>
 </%block>
 
 <%block name="title"><title>${_("{course_number} Staff Grading").format(course_number=course.display_number_with_default) | h}</title></%block>
diff --git a/lms/templates/login.html b/lms/templates/login.html
index 938b1cc9c835..80dab49365e0 100644
--- a/lms/templates/login.html
+++ b/lms/templates/login.html
@@ -1,5 +1,3 @@
-<%! from django.utils.translation import ugettext as _ %>
-
 <%inherit file="main.html" />
 
 <%namespace name='static' file='static_content.html'/>
diff --git a/lms/templates/main.html b/lms/templates/main.html
index 60658111c84b..3d4490877daf 100644
--- a/lms/templates/main.html
+++ b/lms/templates/main.html
@@ -16,9 +16,10 @@
 </%def>
 
 <!DOCTYPE html>
-<!--[if lt IE 8]><html class="ie"><![endif]-->
-<!--[if IE 8]><html class="ie8"><![endif]-->
-<!--[if gte IE 9]><!--><html><!--<![endif]-->
+<!--[if IE 7]><html class="ie ie7 lte9 lte8 lte7"><![endif]-->
+<!--[if IE 8]><html class="ie ie8 lte9 lte8"><![endif]-->
+<!--[if IE 9]><html class="ie ie9 lte9"><![endif]-->
+<!--[if gt IE 9]><!--><html><!--<![endif]-->
 <head>
   <%block name="title">
     % if stanford_theme_enabled():
@@ -45,21 +46,22 @@
 
   <link rel="icon" type="image/x-icon" href="${static.url(settings.FAVICON_PATH)}" />
 
-  <%static:css group='application'/>
+  <%static:css group='style-vendor'/>
+  <%static:css group='style-app'/>
+  <%static:css group='style-app-extend1'/>
+  <%static:css group='style-app-extend2'/>
 
   <%static:js group='main_vendor'/>
+
   <%block name="headextra"/>
   % if theme_enabled():
     <%include file="theme-head-extra.html" />
   % endif
 
   <!--[if lt IE 9]>
-  <script src="${static.url('js/html5shiv.js')}"></script>
+    <script src="${static.url('js/html5shiv.js')}"></script>
   <![endif]-->
 
-  <!--[if lte IE 9]>
-  <%static:css group='ie-fixes'/>
-  <![endif]-->
   <meta name="path_prefix" content="${MITX_ROOT_URL}">
   <meta name="google-site-verification" content="_mipQ4AtZQDNmbtOkwehQDOgCxUUV2fb_C0b6wbiRHY" />
 
diff --git a/lms/templates/main_django.html b/lms/templates/main_django.html
index dbfc43f2e14f..c3f719070b21 100644
--- a/lms/templates/main_django.html
+++ b/lms/templates/main_django.html
@@ -19,9 +19,6 @@
   <script src="${static.url('js/html5shiv.js')}"></script>
   <![endif]-->
 
-  <!--[if lte IE 9]>
-  <%static:css group='ie-fixes'/>
-  <![endif]-->
   <meta name="path_prefix" content="{{MITX_ROOT_URL}}">
 </head>
 
diff --git a/lms/templates/manage_user_standing.html b/lms/templates/manage_user_standing.html
new file mode 100644
index 000000000000..19bc63d667ef
--- /dev/null
+++ b/lms/templates/manage_user_standing.html
@@ -0,0 +1,56 @@
+<%inherit file="main.html" />
+
+<%! from django.core.urlresolvers import reverse %>
+<%! from django.utils.translation import ugettext as _ %>
+
+<h2>${_("Disable or Reenable student accounts")}</h2>
+<form action="${reverse('disable_account_ajax')}" method="post" data-remote="true" id="disable-form">
+	<label for="username">${_("Username:")}</label>
+	<input type="text" id="username" name="username" required="true">
+	<br>
+	<label for="account_action">${_("Disable Account")}</label>
+	<input type="radio" name="account_action" value="disable" id="account_action">
+	<br>
+	<label for="account_action">${_("Reenable Account")}</label>
+	<input type="radio" name="account_action" value="reenable" id="account_action">
+	<br>
+	<br>
+</form>
+
+<button id="submit-form">${_("Submit")}</button>
+<br>
+<br>
+<p id="account-change-status"></p>
+<h2>${_("Students whose accounts have been disabled")}</h2>
+<p>${_("(reload your page to refresh)")}</p>
+<table id="account-table" border='1'>
+	<tr>
+		% for header in headers:
+		<th>${header}</th>
+		% endfor
+	</tr>
+	% for row in rows:
+	<tr>
+		% for cell in row:
+		<td>${cell}</td>
+		% endfor
+	</tr>
+	% endfor
+</table>
+
+<script type="text/javascript">
+	$(function() {
+		var form = $("#disable-form");
+		$("#submit-form").click(function(){
+			$("#account-change-status").html(gettext("working..."));
+			$.ajax({
+				type: "POST",
+				url: form.attr('action'),
+				data: form.serialize(),
+				success: function(response){
+					$("#account-change-status").html(response.message);
+				},
+			});
+		});
+	});
+</script>
diff --git a/lms/templates/mktg_iframe.html b/lms/templates/mktg_iframe.html
index eae71cb881fd..338f49240cbe 100644
--- a/lms/templates/mktg_iframe.html
+++ b/lms/templates/mktg_iframe.html
@@ -1,6 +1,9 @@
 <%namespace name='static' file='static_content.html'/>
 <!DOCTYPE html>
-<html class="view-iframe">
+<!--[if IE 7]><html class="ie ie7 lte9 lte8 lte7 view-iframe"><![endif]-->
+<!--[if IE 8]><html class="ie ie8 lte9 lte8 view-iframe"><![endif]-->
+<!--[if IE 9]><html class="ie ie9 lte9 view-iframe"><![endif]-->
+<!--[if gt IE 9]><!--><html class="view-iframe"><!--<![endif]-->
 <head>
   <%block name="title"></%block>
 
@@ -8,17 +11,15 @@
   <meta name="path_prefix" content="${MITX_ROOT_URL}" />
   <meta name="google-site-verification" content="_mipQ4AtZQDNmbtOkwehQDOgCxUUV2fb_C0b6wbiRHY" />
 
-  <%static:css group='application'/>
+  <%static:css group='style-vendor'/>
+  <%static:css group='style-app'/>
+
   <%static:js group='main_vendor'/>
 
-  <!--[if IE]>
+  <!--[if lt IE 9]>
     <script src="${static.url('js/html5shiv.js')}"></script>
   <![endif]-->
 
-  <!--[if lte IE 9]>
-    <%static:css group='ie-fixes'/>
-  <![endif]-->
-
   <%block name="headextra"/>
 
   % if not course:
diff --git a/lms/templates/notes.html b/lms/templates/notes.html
index 16fdc2ebc910..a5fd914c71a4 100644
--- a/lms/templates/notes.html
+++ b/lms/templates/notes.html
@@ -7,8 +7,10 @@
 %>
 
 <%block name="headextra">
-    <%static:css group='course'/>
-    <%static:js group='courseware'/>
+<%static:css group='style-course-vendor'/>
+<%static:css group='style-course'/>
+<%static:js group='courseware'/>
+
 <style type="text/css">
     blockquote {
         background:#f9f9f9;
diff --git a/lms/templates/open_ended_problems/combined_notifications.html b/lms/templates/open_ended_problems/combined_notifications.html
index ce22a5c580f4..4ac853076cbd 100644
--- a/lms/templates/open_ended_problems/combined_notifications.html
+++ b/lms/templates/open_ended_problems/combined_notifications.html
@@ -4,7 +4,8 @@
 <%namespace name='static' file='/static_content.html'/>
 
 <%block name="headextra">
-<%static:css group='course'/>
+<%static:css group='style-course-vendor'/>
+<%static:css group='style-course'/>
 </%block>
 
 <%block name="title"><title>${_("{course_number} Combined Notifications").format(course_number=course.display_number_with_default) | h}</title></%block>
diff --git a/lms/templates/open_ended_problems/open_ended_flagged_problems.html b/lms/templates/open_ended_problems/open_ended_flagged_problems.html
index 8e746f585f58..db83f755141d 100644
--- a/lms/templates/open_ended_problems/open_ended_flagged_problems.html
+++ b/lms/templates/open_ended_problems/open_ended_flagged_problems.html
@@ -4,7 +4,8 @@
 <%namespace name='static' file='/static_content.html'/>
 
 <%block name="headextra">
-<%static:css group='course'/>
+<%static:css group='style-course-vendor'/>
+<%static:css group='style-course'/>
 </%block>
 
 <%block name="title"><title>${_("{course_number} Flagged Open Ended Problems").format(course_number=course.display_number_with_default) | h}</title></%block>
diff --git a/lms/templates/open_ended_problems/open_ended_problems.html b/lms/templates/open_ended_problems/open_ended_problems.html
index 1c7e2657ed9d..3fe03bac0f0f 100644
--- a/lms/templates/open_ended_problems/open_ended_problems.html
+++ b/lms/templates/open_ended_problems/open_ended_problems.html
@@ -4,7 +4,8 @@
 <%namespace name='static' file='/static_content.html'/>
 
 <%block name="headextra">
-<%static:css group='course'/>
+<%static:css group='style-course-vendor'/>
+<%static:css group='style-course'/>
 </%block>
 
 <%block name="title"><title>${_("{course_number} Open Ended Problems").format(course_number=course.display_number_with_default) | h}</title></%block>
diff --git a/lms/templates/static_htmlbook.html b/lms/templates/static_htmlbook.html
index 60421502e67a..56e53ceffcdb 100644
--- a/lms/templates/static_htmlbook.html
+++ b/lms/templates/static_htmlbook.html
@@ -6,7 +6,8 @@
 </%block>
 
 <%block name="headextra">
-<%static:css group='course'/>
+<%static:css group='style-course-vendor'/>
+<%static:css group='style-course'/>
 <%static:js group='courseware'/>
 </%block>
 
diff --git a/lms/templates/static_pdfbook.html b/lms/templates/static_pdfbook.html
index d1ec14c1a67c..0b5f5add61cf 100644
--- a/lms/templates/static_pdfbook.html
+++ b/lms/templates/static_pdfbook.html
@@ -9,7 +9,8 @@
 </%block>
 
 <%block name="headextra">
-<%static:css group='course'/>
+<%static:css group='style-course-vendor'/>
+<%static:css group='style-course'/>
 <%static:js group='courseware'/>
 <link rel="stylesheet" href="/static/css/pdfviewer.css"/>
 <script type="text/javascript" src="/static/js/vendor/pdfjs/pdf.js"></script>
diff --git a/lms/templates/staticbook.html b/lms/templates/staticbook.html
index 3b32585c7a4b..d17253977394 100644
--- a/lms/templates/staticbook.html
+++ b/lms/templates/staticbook.html
@@ -5,7 +5,9 @@
 <%block name="title"><title>${_("{course_number} Textbook").format(course_number=course.display_number_with_default) | h}</title></%block>
 
 <%block name="headextra">
-<%static:css group='course'/>
+<%static:css group='style-course-vendor'/>
+<%static:css group='style-course'/>
+
 <%static:js group='courseware'/>
 </%block>
 
diff --git a/lms/templates/stripped-main.html b/lms/templates/stripped-main.html
index c6c193e2694b..d092c47ee1d2 100644
--- a/lms/templates/stripped-main.html
+++ b/lms/templates/stripped-main.html
@@ -2,26 +2,26 @@
 
 <%namespace name='static' file='static_content.html'/>
 <!DOCTYPE html>
-<html>
+<!--[if IE 7]><html class="ie ie7 lte9 lte8 lte7"><![endif]-->
+<!--[if IE 8]><html class="ie ie8 lte9 lte8"><![endif]-->
+<!--[if IE 9]><html class="ie ie9 lte9"><![endif]-->
+<!--[if gt IE 9]><!--><html><!--<![endif]-->
 <head>
   ## "edX" should not be translated
   <%block name="title"><title>edX</title></%block>
 
   <link rel="icon" type="image/x-icon" href="${static.url('images/favicon.ico')}" />
 
-  <%static:css group='application'/>
+  <%static:css group='style-vendor'/>
+  <%static:css group='style-app'/>
 
   <%static:js group='main_vendor'/>
   <%block name="headextra"/>
 
-
   <!--[if lt IE 9]>
   <script src="${static.url('js/html5shiv.js')}"></script>
   <![endif]-->
 
-  <!--[if lte IE 9]>
-  <%static:css group='ie-fixes'/>
-  <![endif]-->
   <meta name="path_prefix" content="${MITX_ROOT_URL}">
 </head>
 
diff --git a/lms/templates/video.html b/lms/templates/video.html
index caf0aaa06fba..d0e61a5f745a 100644
--- a/lms/templates/video.html
+++ b/lms/templates/video.html
@@ -26,6 +26,19 @@ <h2>${display_name}</h2>
     data-yt-test-timeout="${yt_test_timeout}"
     data-yt-test-url="${yt_test_url}"
 
+    ## For now, the option "data-autohide-html5" is hard coded. This option
+    ## either enables or disables autohiding of controls and captions on mouse
+    ## inactivity. If set to true, controls and captions will autohide for
+    ## HTML5 sources (non-YouTube) after a period of mouse inactivity over the
+    ## whole video. When the mouse moves (or a key is pressed while any part of
+    ## the video player is focused), the captions and controls will be shown
+    ## once again.
+    ##
+    ## There is no option in the "Advanced Editor" to set this option. However,
+    ## this option will have an effect if changed to "True". The code on
+    ## front-end exists.
+    data-autohide-html5="False"
+
     tabindex="-1"
 >
     <div class="focus_grabber first"></div>
diff --git a/lms/urls.py b/lms/urls.py
index e624ac9f3431..e187cf3ff668 100644
--- a/lms/urls.py
+++ b/lms/urls.py
@@ -30,6 +30,10 @@
     url(r'^t/(?P<template>[^/]*)$', 'static_template_view.views.index'),   # TODO: Is this used anymore? What is STATIC_GRAB?
 
     url(r'^accounts/login$', 'student.views.accounts_login', name="accounts_login"),
+    url(r'^accounts/manage_user_standing', 'student.views.manage_user_standing',
+        name='manage_user_standing'),
+    url(r'^accounts/disable_account_ajax$', 'student.views.disable_account_ajax',
+        name="disable_account_ajax"),
 
     url(r'^login_ajax$', 'student.views.login_user', name="login"),
     url(r'^login_ajax/(?P<error>[^/]*)$', 'student.views.login_user'),
diff --git a/requirements/edx/github.txt b/requirements/edx/github.txt
index 3a95566b2b71..f5b36dad33e7 100644
--- a/requirements/edx/github.txt
+++ b/requirements/edx/github.txt
@@ -16,6 +16,6 @@
 # Our libraries:
 -e git+https://github.com/edx/XBlock.git@8a66ca3#egg=XBlock
 -e git+https://github.com/edx/codejail.git@0a1b468#egg=codejail
--e git+https://github.com/edx/diff-cover.git@v0.2.4#egg=diff_cover
--e git+https://github.com/edx/js-test-tool.git@v0.0.7#egg=js_test_tool
+-e git+https://github.com/edx/diff-cover.git@v0.2.6#egg=diff_cover
+-e git+https://github.com/edx/js-test-tool.git@v0.1.1#egg=js_test_tool
 -e git+https://github.com/edx/django-waffle.git@823a102e48#egg=django-waffle