Bug 1107683 - remove method callbacks from CameraControl, r=aosmond,bz
authorMike Habicher <mikeh@mozilla.com>
Thu, 11 Dec 2014 11:02:51 -0500
changeset 219181 12c5cc6e88b326e2e4006fc6573bf01e0fea54c2
parent 219180 2905ba16f162f1c6f7e730322fe519a3fc3758c2
child 219182 8642c98bb2297c79a4a1b463d02443eab679fe09
push id27957
push userkwierso@gmail.com
push dateFri, 12 Dec 2014 01:07:10 +0000
treeherdermozilla-central@190b2d00739f [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersaosmond, bz
bugs1107683
milestone37.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1107683 - remove method callbacks from CameraControl, r=aosmond,bz
dom/camera/DOMCameraControl.cpp
dom/camera/DOMCameraControl.h
dom/camera/DOMCameraManager.cpp
dom/camera/DOMCameraManager.h
dom/camera/test/callback/test_bug1022766.html
dom/camera/test/callback/test_bug1099390.html
dom/camera/test/callback/test_bug975472.html
dom/camera/test/callback/test_camera.html
dom/camera/test/callback/test_camera_2.html
dom/camera/test/callback/test_camera_3.html
dom/camera/test/callback/test_camera_hardware_auto_focus_moving_cb.html
dom/camera/test/callback/test_camera_hardware_face_detection.html
dom/camera/test/callback/test_camera_hardware_failures.html
dom/camera/test/callback/test_camera_hardware_init_failure.html
dom/camera/test/mochitest.ini
dom/camera/test/test_bug1022766.html
dom/camera/test/test_camera.html
dom/camera/test/test_camera_fake_parameters.html
dom/webidl/CameraControl.webidl
dom/webidl/CameraManager.webidl
gfx/layers/apz/src/InputBlockState.h.orig
modules/libpref/init/all.js
--- a/dom/camera/DOMCameraControl.cpp
+++ b/dom/camera/DOMCameraControl.cpp
@@ -63,36 +63,17 @@ NS_IMPL_RELEASE_INHERITED(nsDOMCameraCon
 NS_IMPL_CYCLE_COLLECTION_INHERITED(nsDOMCameraControl, DOMMediaStream,
                                    mCapabilities,
                                    mWindow,
                                    mGetCameraPromise,
                                    mAutoFocusPromise,
                                    mTakePicturePromise,
                                    mStartRecordingPromise,
                                    mReleasePromise,
-                                   mSetConfigurationPromise,
-                                   mGetCameraOnSuccessCb,
-                                   mGetCameraOnErrorCb,
-                                   mAutoFocusOnSuccessCb,
-                                   mAutoFocusOnErrorCb,
-                                   mTakePictureOnSuccessCb,
-                                   mTakePictureOnErrorCb,
-                                   mStartRecordingOnSuccessCb,
-                                   mStartRecordingOnErrorCb,
-                                   mReleaseOnSuccessCb,
-                                   mReleaseOnErrorCb,
-                                   mSetConfigurationOnSuccessCb,
-                                   mSetConfigurationOnErrorCb,
-                                   mOnShutterCb,
-                                   mOnClosedCb,
-                                   mOnRecorderStateChangeCb,
-                                   mOnPreviewStateChangeCb,
-                                   mOnAutoFocusMovingCb,
-                                   mOnAutoFocusCompletedCb,
-                                   mOnFacesDetectedCb)
+                                   mSetConfigurationPromise)
 
 /* static */
 bool
 nsDOMCameraControl::HasSupport(JSContext* aCx, JSObject* aGlobal)
 {
   return Navigator::HasCameraSupport(aCx, aGlobal);
 }
 
@@ -202,43 +183,22 @@ nsDOMCameraControl::DiscardCachedCameraI
 
   sDiscardCachedCameraControlTimer = nullptr;
   sCachedCameraControl = nullptr;
 }
 #endif
 
 nsDOMCameraControl::nsDOMCameraControl(uint32_t aCameraId,
                                        const CameraConfiguration& aInitialConfig,
-                                       GetCameraCallback* aOnSuccess,
-                                       CameraErrorCallback* aOnError,
                                        Promise* aPromise,
                                        nsPIDOMWindow* aWindow)
   : DOMMediaStream()
   , mCameraControl(nullptr)
   , mAudioChannelAgent(nullptr)
   , mGetCameraPromise(aPromise)
-  , mGetCameraOnSuccessCb(aOnSuccess)
-  , mGetCameraOnErrorCb(aOnError)
-  , mAutoFocusOnSuccessCb(nullptr)
-  , mAutoFocusOnErrorCb(nullptr)
-  , mTakePictureOnSuccessCb(nullptr)
-  , mTakePictureOnErrorCb(nullptr)
-  , mStartRecordingOnSuccessCb(nullptr)
-  , mStartRecordingOnErrorCb(nullptr)
-  , mReleaseOnSuccessCb(nullptr)
-  , mReleaseOnErrorCb(nullptr)
-  , mSetConfigurationOnSuccessCb(nullptr)
-  , mSetConfigurationOnErrorCb(nullptr)
-  , mOnShutterCb(nullptr)
-  , mOnClosedCb(nullptr)
-  , mOnRecorderStateChangeCb(nullptr)
-  , mOnPreviewStateChangeCb(nullptr)
-  , mOnAutoFocusMovingCb(nullptr)
-  , mOnAutoFocusCompletedCb(nullptr)
-  , mOnFacesDetectedCb(nullptr)
   , mWindow(aWindow)
   , mPreviewState(CameraControlListener::kPreviewStopped)
 {
   DOM_CAMERA_LOGT("%s:%d : this=%p\n", __func__, __LINE__, this);
   mInput = new CameraPreviewMediaStream(this);
 
   BindToOwner(aWindow);
 
@@ -660,153 +620,45 @@ nsDOMCameraControl::SensorAngle()
 {
   MOZ_ASSERT(mCameraControl);
 
   int32_t angle = 0;
   mCameraControl->Get(CAMERA_PARAM_SENSORANGLE, angle);
   return angle;
 }
 
-// Callback attributes
-
-CameraShutterCallback*
-nsDOMCameraControl::GetOnShutter()
-{
-  return mOnShutterCb;
-}
-void
-nsDOMCameraControl::SetOnShutter(CameraShutterCallback* aCb)
-{
-  mOnShutterCb = aCb;
-}
-
-CameraClosedCallback*
-nsDOMCameraControl::GetOnClosed()
-{
-  return mOnClosedCb;
-}
-void
-nsDOMCameraControl::SetOnClosed(CameraClosedCallback* aCb)
-{
-  mOnClosedCb = aCb;
-}
-
-CameraRecorderStateChange*
-nsDOMCameraControl::GetOnRecorderStateChange()
-{
-  return mOnRecorderStateChangeCb;
-}
-void
-nsDOMCameraControl::SetOnRecorderStateChange(CameraRecorderStateChange* aCb)
-{
-  mOnRecorderStateChangeCb = aCb;
-}
-
-CameraPreviewStateChange*
-nsDOMCameraControl::GetOnPreviewStateChange()
-{
-  return mOnPreviewStateChangeCb;
-}
-void
-nsDOMCameraControl::SetOnPreviewStateChange(CameraPreviewStateChange* aCb)
-{
-  mOnPreviewStateChangeCb = aCb;
-}
-
-CameraAutoFocusMovingCallback*
-nsDOMCameraControl::GetOnAutoFocusMoving()
-{
-  return mOnAutoFocusMovingCb;
-}
-void
-nsDOMCameraControl::SetOnAutoFocusMoving(CameraAutoFocusMovingCallback* aCb)
-{
-  mOnAutoFocusMovingCb = aCb;
-}
-
-CameraAutoFocusCallback*
-nsDOMCameraControl::GetOnAutoFocusCompleted()
-{
-  return mOnAutoFocusCompletedCb;
-}
-void
-nsDOMCameraControl::SetOnAutoFocusCompleted(CameraAutoFocusCallback* aCb)
-{
-  mOnAutoFocusCompletedCb = aCb;
-}
-
-CameraFaceDetectionCallback*
-nsDOMCameraControl::GetOnFacesDetected()
-{
-  return mOnFacesDetectedCb;
-}
-void
-nsDOMCameraControl::SetOnFacesDetected(CameraFaceDetectionCallback* aCb)
-{
-  mOnFacesDetectedCb = aCb;
-}
-
 already_AddRefed<dom::CameraCapabilities>
 nsDOMCameraControl::Capabilities()
 {
   nsRefPtr<CameraCapabilities> caps = mCapabilities;
 
   if (!caps) {
     caps = new CameraCapabilities(mWindow, mCameraControl);
     mCapabilities = caps;
   }
 
   return caps.forget();
 }
 
-class ImmediateErrorCallback : public nsRunnable
-{
-public:
-  ImmediateErrorCallback(CameraErrorCallback* aCallback, const nsAString& aMessage)
-    : mCallback(aCallback)
-    , mMessage(aMessage)
-  { }
-
-  NS_IMETHODIMP
-  Run()
-  {
-    MOZ_ASSERT(NS_IsMainThread());
-    ErrorResult ignored;
-    mCallback->Call(mMessage, ignored);
-    return NS_OK;
-  }
-
-protected:
-  nsRefPtr<CameraErrorCallback> mCallback;
-  nsString mMessage;
-};
-
 // Methods.
 already_AddRefed<Promise>
 nsDOMCameraControl::StartRecording(const CameraStartRecordingOptions& aOptions,
                                    nsDOMDeviceStorage& aStorageArea,
                                    const nsAString& aFilename,
-                                   const Optional<OwningNonNull<CameraStartRecordingCallback> >& aOnSuccess,
-                                   const Optional<OwningNonNull<CameraErrorCallback> >& aOnError,
                                    ErrorResult& aRv)
 {
   MOZ_ASSERT(mCameraControl);
 
   nsRefPtr<Promise> promise = CreatePromise(aRv);
   if (aRv.Failed()) {
     return nullptr;
   }
 
   if (mStartRecordingPromise) {
     promise->MaybeReject(NS_ERROR_IN_PROGRESS);
-    if (aOnError.WasPassed()) {
-      DOM_CAMERA_LOGT("%s:onError WasPassed\n", __func__);
-      NS_DispatchToMainThread(new ImmediateErrorCallback(&aOnError.Value(),
-                              NS_LITERAL_STRING("StartRecordingInProgress")));
-    }
     return promise.forget();
   }
 
   NotifyRecordingStatusChange(NS_LITERAL_STRING("starting"));
 
 #ifdef MOZ_B2G
   if (!mAudioChannelAgent) {
     mAudioChannelAgent = do_CreateInstance("@mozilla.org/audiochannelagent;1");
@@ -825,24 +677,16 @@ nsDOMCameraControl::StartRecording(const
   aRv = aStorageArea.CreateFileDescriptor(aFilename, mDSFileDescriptor.get(),
                                           getter_AddRefs(request));
   if (aRv.Failed()) {
     return nullptr;
   }
 
   mStartRecordingPromise = promise;
   mOptions = aOptions;
-  mStartRecordingOnSuccessCb = nullptr;
-  if (aOnSuccess.WasPassed()) {
-    mStartRecordingOnSuccessCb = &aOnSuccess.Value();
-  }
-  mStartRecordingOnErrorCb = nullptr;
-  if (aOnError.WasPassed()) {
-    mStartRecordingOnErrorCb = &aOnError.Value();
-  }
 
   nsCOMPtr<nsIDOMEventListener> listener = new StartRecordingHelper(this);
   request->AddEventListener(NS_LITERAL_STRING("success"), listener, false);
   request->AddEventListener(NS_LITERAL_STRING("error"), listener, false);
   return promise.forget();
 }
 
 void
@@ -894,36 +738,28 @@ void
 nsDOMCameraControl::ResumePreview(ErrorResult& aRv)
 {
   MOZ_ASSERT(mCameraControl);
   aRv = mCameraControl->StartPreview();
 }
 
 already_AddRefed<Promise>
 nsDOMCameraControl::SetConfiguration(const CameraConfiguration& aConfiguration,
-                                     const Optional<OwningNonNull<CameraSetConfigurationCallback> >& aOnSuccess,
-                                     const Optional<OwningNonNull<CameraErrorCallback> >& aOnError,
                                      ErrorResult& aRv)
 {
   MOZ_ASSERT(mCameraControl);
 
   nsRefPtr<Promise> promise = CreatePromise(aRv);
   if (aRv.Failed()) {
     return nullptr;
   }
 
   if (mTakePicturePromise) {
+    // We're busy taking a picture, can't change modes right now.
     promise->MaybeReject(NS_ERROR_IN_PROGRESS);
-    // We're busy taking a picture, can't change modes right now.
-    if (aOnError.WasPassed()) {
-      // There is already a call to TakePicture() in progress, abort this
-      // call and invoke the error callback (if one was passed in).
-      NS_DispatchToMainThread(new ImmediateErrorCallback(&aOnError.Value(),
-                              NS_LITERAL_STRING("TakePictureInProgress")));
-    }
     return promise.forget();
   }
 
   ICameraControl::Configuration config;
   config.mRecorderProfile = aConfiguration.mRecorderProfile;
   config.mPreviewSize.width = aConfiguration.mPreviewSize.mWidth;
   config.mPreviewSize.height = aConfiguration.mPreviewSize.mHeight;
   config.mMode = ICameraControl::kPictureMode;
@@ -932,68 +768,44 @@ nsDOMCameraControl::SetConfiguration(con
   }
 
   aRv = mCameraControl->SetConfiguration(config);
   if (aRv.Failed()) {
     return nullptr;
   }
 
   mSetConfigurationPromise = promise;
-  mSetConfigurationOnSuccessCb = nullptr;
-  if (aOnSuccess.WasPassed()) {
-    mSetConfigurationOnSuccessCb = &aOnSuccess.Value();
-  }
-  mSetConfigurationOnErrorCb = nullptr;
-  if (aOnError.WasPassed()) {
-    mSetConfigurationOnErrorCb = &aOnError.Value();
-  }
   return promise.forget();
 }
 
 already_AddRefed<Promise>
-nsDOMCameraControl::AutoFocus(const Optional<OwningNonNull<CameraAutoFocusCallback> >& aOnSuccess,
-                              const Optional<OwningNonNull<CameraErrorCallback> >& aOnError,
-                              ErrorResult& aRv)
+nsDOMCameraControl::AutoFocus(ErrorResult& aRv)
 {
   MOZ_ASSERT(mCameraControl);
 
   nsRefPtr<Promise> promise = mAutoFocusPromise.forget();
   if (promise) {
     // There is already a call to AutoFocus() in progress, cancel it and
     // invoke the error callback (if one was passed in).
     promise->MaybeReject(NS_ERROR_IN_PROGRESS);
-    mAutoFocusOnSuccessCb = nullptr;
-    nsRefPtr<CameraErrorCallback> ecb = mAutoFocusOnErrorCb.forget();
-    if (ecb) {
-      NS_DispatchToMainThread(new ImmediateErrorCallback(ecb,
-                              NS_LITERAL_STRING("AutoFocusInterrupted")));
-    }
   }
 
   promise = CreatePromise(aRv);
   if (aRv.Failed()) {
     return nullptr;
   }
 
   aRv = mCameraControl->AutoFocus();
   if (aRv.Failed()) {
     return nullptr;
   }
 
   DispatchStateEvent(NS_LITERAL_STRING("focus"), NS_LITERAL_STRING("focusing"));
 
   mAutoFocusPromise = promise;
-  mAutoFocusOnSuccessCb = nullptr;
-  if (aOnSuccess.WasPassed()) {
-    mAutoFocusOnSuccessCb = &aOnSuccess.Value();
-  }
-  mAutoFocusOnErrorCb = nullptr;
-  if (aOnError.WasPassed()) {
-    mAutoFocusOnErrorCb = &aOnError.Value();
-  }
   return promise.forget();
 }
 
 void
 nsDOMCameraControl::StartFaceDetection(ErrorResult& aRv)
 {
   MOZ_ASSERT(mCameraControl);
   aRv = mCameraControl->StartFaceDetection();
@@ -1003,35 +815,29 @@ void
 nsDOMCameraControl::StopFaceDetection(ErrorResult& aRv)
 {
   MOZ_ASSERT(mCameraControl);
   aRv = mCameraControl->StopFaceDetection();
 }
 
 already_AddRefed<Promise>
 nsDOMCameraControl::TakePicture(const CameraPictureOptions& aOptions,
-                                const Optional<OwningNonNull<CameraTakePictureCallback> >& aOnSuccess,
-                                const Optional<OwningNonNull<CameraErrorCallback> >& aOnError,
                                 ErrorResult& aRv)
 {
   MOZ_ASSERT(mCameraControl);
 
   nsRefPtr<Promise> promise = CreatePromise(aRv);
   if (aRv.Failed()) {
     return nullptr;
   }
 
   if (mTakePicturePromise) {
     // There is already a call to TakePicture() in progress, abort this new
     // one and invoke the error callback (if one was passed in).
     promise->MaybeReject(NS_ERROR_IN_PROGRESS);
-    if (aOnError.WasPassed()) {
-      NS_DispatchToMainThread(new ImmediateErrorCallback(&aOnError.Value(),
-                              NS_LITERAL_STRING("TakePictureAlreadyInProgress")));
-    }
     return promise.forget();
   }
 
   {
     ICameraControlParameterSetAutoEnter batch(mCameraControl);
 
     // XXXmikeh - remove this: see bug 931155
     ICameraControl::Size s;
@@ -1054,53 +860,35 @@ nsDOMCameraControl::TakePicture(const Ca
   }
 
   aRv = mCameraControl->TakePicture();
   if (aRv.Failed()) {
     return nullptr;
   }
 
   mTakePicturePromise = promise;
-  mTakePictureOnSuccessCb = nullptr;
-  if (aOnSuccess.WasPassed()) {
-    mTakePictureOnSuccessCb = &aOnSuccess.Value();
-  }
-  mTakePictureOnErrorCb = nullptr;
-  if (aOnError.WasPassed()) {
-    mTakePictureOnErrorCb = &aOnError.Value();
-  }
   return promise.forget();
 }
 
 already_AddRefed<Promise>
-nsDOMCameraControl::ReleaseHardware(const Optional<OwningNonNull<CameraReleaseCallback> >& aOnSuccess,
-                                    const Optional<OwningNonNull<CameraErrorCallback> >& aOnError,
-                                    ErrorResult& aRv)
+nsDOMCameraControl::ReleaseHardware(ErrorResult& aRv)
 {
   MOZ_ASSERT(mCameraControl);
 
   nsRefPtr<Promise> promise = CreatePromise(aRv);
   if (aRv.Failed()) {
     return nullptr;
   }
 
   aRv = mCameraControl->Stop();
   if (aRv.Failed()) {
     return nullptr;
   }
 
   mReleasePromise = promise;
-  mReleaseOnSuccessCb = nullptr;
-  if (aOnSuccess.WasPassed()) {
-    mReleaseOnSuccessCb = &aOnSuccess.Value();
-  }
-  mReleaseOnErrorCb = nullptr;
-  if (aOnError.WasPassed()) {
-    mReleaseOnErrorCb = &aOnError.Value();
-  }
   return promise.forget();
 }
 
 void
 nsDOMCameraControl::ResumeContinuousFocus(ErrorResult& aRv)
 {
   MOZ_ASSERT(mCameraControl);
   aRv = mCameraControl->ResumeContinuousFocus();
@@ -1116,37 +904,16 @@ nsDOMCameraControl::Shutdown()
   // reference our window object, which in turn references
   // us. If we don't remove them, we can leak DOM objects.
   AbortPromise(mGetCameraPromise);
   AbortPromise(mAutoFocusPromise);
   AbortPromise(mTakePicturePromise);
   AbortPromise(mStartRecordingPromise);
   AbortPromise(mReleasePromise);
   AbortPromise(mSetConfigurationPromise);
-  mGetCameraOnSuccessCb = nullptr;
-  mGetCameraOnErrorCb = nullptr;
-  mAutoFocusOnSuccessCb = nullptr;
-  mAutoFocusOnErrorCb = nullptr;
-  mTakePictureOnSuccessCb = nullptr;
-  mTakePictureOnErrorCb = nullptr;
-  mStartRecordingOnSuccessCb = nullptr;
-  mStartRecordingOnErrorCb = nullptr;
-  mReleaseOnSuccessCb = nullptr;
-  mReleaseOnErrorCb = nullptr;
-  mSetConfigurationOnSuccessCb = nullptr;
-  mSetConfigurationOnErrorCb = nullptr;
-
-  // Remove all of the unsolicited event handlers too.
-  mOnShutterCb = nullptr;
-  mOnClosedCb = nullptr;
-  mOnRecorderStateChangeCb = nullptr;
-  mOnPreviewStateChangeCb = nullptr;
-  mOnAutoFocusMovingCb = nullptr;
-  mOnAutoFocusCompletedCb = nullptr;
-  mOnFacesDetectedCb = nullptr;
 
   mCameraControl->Shutdown();
 }
 
 nsresult
 nsDOMCameraControl::NotifyRecordingStatusChange(const nsString& aMsg)
 {
   NS_ENSURE_TRUE(mWindow, NS_ERROR_FAILURE);
@@ -1231,40 +998,27 @@ nsDOMCameraControl::OnHardwareStateChang
         // the preview hasn't started yet.
         nsRefPtr<Promise> promise = mGetCameraPromise.forget();
         if (promise) {
           CameraGetPromiseData data;
           data.mCamera = this;
           data.mConfiguration = *mCurrentConfiguration;
           promise->MaybeResolve(data);
         }
-        nsRefPtr<GetCameraCallback> cb = mGetCameraOnSuccessCb.forget();
-        mGetCameraOnErrorCb = nullptr;
-        if (cb) {
-          ErrorResult ignored;
-          cb->Call(*this, *mCurrentConfiguration, ignored);
-        }
       }
       break;
 
     case CameraControlListener::kHardwareClosed:
       DOM_CAMERA_LOGI("DOM OnHardwareStateChange: closed\n");
       {
         nsRefPtr<Promise> promise = mReleasePromise.forget();
         if (promise) {
           promise->MaybeResolve(JS::UndefinedHandleValue);
         }
 
-        nsRefPtr<CameraReleaseCallback> rcb = mReleaseOnSuccessCb.forget();
-        mReleaseOnErrorCb = nullptr;
-        if (rcb) {
-          ErrorResult ignored;
-          rcb->Call(ignored);
-        }
-
         CameraClosedEventInit eventInit;
         switch (aReason) {
           case NS_OK:
             eventInit.mReason = NS_LITERAL_STRING("HardwareReleased");
             break;
 
           case NS_ERROR_FAILURE:
             eventInit.mReason = NS_LITERAL_STRING("SystemFailure");
@@ -1276,20 +1030,16 @@ nsDOMCameraControl::OnHardwareStateChang
 
           default:
             DOM_CAMERA_LOGE("Unhandled hardware close reason, 0x%x\n", aReason);
             MOZ_ASSERT_UNREACHABLE("Unanticipated reason for hardware close");
             eventInit.mReason = NS_LITERAL_STRING("SystemFailure");
             break;
         }
 
-        nsRefPtr<CameraClosedCallback> cb = mOnClosedCb;
-        if (cb) {
-          cb->Call(eventInit.mReason, ignored);
-        }
         nsRefPtr<CameraClosedEvent> event =
           CameraClosedEvent::Constructor(this,
                                          NS_LITERAL_STRING("close"),
                                          eventInit);
         DispatchTrustedEvent(event);
       }
       break;
 
@@ -1306,23 +1056,16 @@ nsDOMCameraControl::OnHardwareStateChang
 }
 
 void
 nsDOMCameraControl::OnShutter()
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   DOM_CAMERA_LOGI("DOM ** SNAP **\n");
-
-  nsRefPtr<CameraShutterCallback> cb = mOnShutterCb;
-  if (cb) {
-    ErrorResult ignored;
-    cb->Call(ignored);
-  }
-
   DispatchTrustedEvent(NS_LITERAL_STRING("shutter"));
 }
 
 void
 nsDOMCameraControl::OnPreviewStateChange(CameraControlListener::PreviewState aState)
 {
   MOZ_ASSERT(NS_IsMainThread());
 
@@ -1333,22 +1076,16 @@ nsDOMCameraControl::OnPreviewStateChange
       state = NS_LITERAL_STRING("started");
       break;
 
     default:
       state = NS_LITERAL_STRING("stopped");
       break;
   }
 
-  nsRefPtr<CameraPreviewStateChange> cb = mOnPreviewStateChangeCb;
-  if (cb) {
-    ErrorResult ignored;
-    cb->Call(state, ignored);
-  }
-
   DispatchPreviewStateEvent(aState);
 }
 
 void
 nsDOMCameraControl::OnRecorderStateChange(CameraControlListener::RecorderState aState,
                                           int32_t aArg, int32_t aTrackNum)
 {
   // For now, we do nothing with 'aStatus' and 'aTrackNum'.
@@ -1360,21 +1097,16 @@ nsDOMCameraControl::OnRecorderStateChang
   switch (aState) {
     case CameraControlListener::kRecorderStarted:
       {
         nsRefPtr<Promise> promise = mStartRecordingPromise.forget();
         if (promise) {
           promise->MaybeResolve(JS::UndefinedHandleValue);
         }
 
-        nsRefPtr<CameraStartRecordingCallback> scb = mStartRecordingOnSuccessCb.forget();
-        mStartRecordingOnErrorCb = nullptr;
-        if (scb) {
-          scb->Call(ignored);
-        }
         state = NS_LITERAL_STRING("Started");
       }
       break;
 
     case CameraControlListener::kRecorderStopped:
       NotifyRecordingStatusChange(NS_LITERAL_STRING("shutdown"));
       state = NS_LITERAL_STRING("Stopped");
       break;
@@ -1405,21 +1137,16 @@ nsDOMCameraControl::OnRecorderStateChang
       break;
 #endif
 
     default:
       MOZ_ASSERT_UNREACHABLE("Unanticipated video recorder error");
       return;
   }
 
-  nsRefPtr<CameraRecorderStateChange> cb = mOnRecorderStateChangeCb;
-  if (cb) {
-    cb->Call(state, ignored);
-  }
-
   DispatchStateEvent(NS_LITERAL_STRING("recorderstatechange"), state);
 }
 
 void
 nsDOMCameraControl::OnConfigurationChange(DOMCameraConfiguration* aConfiguration)
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(aConfiguration != nullptr);
@@ -1439,23 +1166,16 @@ nsDOMCameraControl::OnConfigurationChang
   DOM_CAMERA_LOGI("    recorder profile       : %s\n",
     NS_ConvertUTF16toUTF8(mCurrentConfiguration->mRecorderProfile).get());
 
   nsRefPtr<Promise> promise = mSetConfigurationPromise.forget();
   if (promise) {
     promise->MaybeResolve(*aConfiguration);
   }
 
-  nsRefPtr<CameraSetConfigurationCallback> cb = mSetConfigurationOnSuccessCb.forget();
-  mSetConfigurationOnErrorCb = nullptr;
-  if (cb) {
-    ErrorResult ignored;
-    cb->Call(*mCurrentConfiguration, ignored);
-  }
-
   CameraConfigurationEventInit eventInit;
   eventInit.mMode = mCurrentConfiguration->mMode;
   eventInit.mRecorderProfile = mCurrentConfiguration->mRecorderProfile;
   eventInit.mPreviewSize = new DOMRect(this, 0, 0,
                                        mCurrentConfiguration->mPreviewSize.mWidth,
                                        mCurrentConfiguration->mPreviewSize.mHeight);
 
   nsRefPtr<CameraConfigurationEvent> event =
@@ -1471,47 +1191,28 @@ nsDOMCameraControl::OnAutoFocusComplete(
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   nsRefPtr<Promise> promise = mAutoFocusPromise.forget();
   if (promise) {
     promise->MaybeResolve(aAutoFocusSucceeded);
   }
 
-  nsRefPtr<CameraAutoFocusCallback> cb = mAutoFocusOnSuccessCb.forget();
-  mAutoFocusOnErrorCb = nullptr;
-  if (cb) {
-    ErrorResult ignored;
-    cb->Call(aAutoFocusSucceeded, ignored);
-  }
-
-  cb = mOnAutoFocusCompletedCb;
-  if (cb) {
-    ErrorResult ignored;
-    cb->Call(aAutoFocusSucceeded, ignored);
-  }
-
   if (aAutoFocusSucceeded) {
     DispatchStateEvent(NS_LITERAL_STRING("focus"), NS_LITERAL_STRING("focused"));
   } else {
     DispatchStateEvent(NS_LITERAL_STRING("focus"), NS_LITERAL_STRING("unfocused"));
   }
 }
 
 void
 nsDOMCameraControl::OnAutoFocusMoving(bool aIsMoving)
 {
   MOZ_ASSERT(NS_IsMainThread());
 
-  nsRefPtr<CameraAutoFocusMovingCallback> cb = mOnAutoFocusMovingCb;
-  if (cb) {
-    ErrorResult ignored;
-    cb->Call(aIsMoving, ignored);
-  }
-
   if (aIsMoving) {
     DispatchStateEvent(NS_LITERAL_STRING("focus"), NS_LITERAL_STRING("focusing"));
   }
 }
 
 void
 nsDOMCameraControl::OnFacesDetected(const nsTArray<ICameraControl::Face>& aFaces)
 {
@@ -1524,22 +1225,16 @@ nsDOMCameraControl::OnFacesDetected(cons
   if (faces.SetCapacity(len)) {
     nsRefPtr<DOMCameraDetectedFace> f;
     for (uint32_t i = 0; i < len; ++i) {
       f = new DOMCameraDetectedFace(this, aFaces[i]);
       *faces.AppendElement() = f.forget().take();
     }
   }
 
-  nsRefPtr<CameraFaceDetectionCallback> cb = mOnFacesDetectedCb;
-  if (cb) {
-    ErrorResult ignored;
-    cb->Call(faces, ignored);
-  }
-
   CameraFacesDetectedEventInit eventInit;
   eventInit.mFaces.SetValue(faces);
 
   nsRefPtr<CameraFacesDetectedEvent> event =
     CameraFacesDetectedEvent::Constructor(this,
                                           NS_LITERAL_STRING("facesdetected"),
                                           eventInit);
 
@@ -1554,94 +1249,67 @@ nsDOMCameraControl::OnTakePictureComplet
 
   nsRefPtr<Promise> promise = mTakePicturePromise.forget();
   if (promise) {
     nsCOMPtr<nsIDOMBlob> picture = aPicture;
     promise->MaybeResolve(picture);
   }
 
   nsRefPtr<File> blob = static_cast<File*>(aPicture);
-
-  nsRefPtr<CameraTakePictureCallback> cb = mTakePictureOnSuccessCb.forget();
-  mTakePictureOnErrorCb = nullptr;
-  if (cb) {
-    ErrorResult ignored;
-    cb->Call(*blob, ignored);
-  }
-
   BlobEventInit eventInit;
   eventInit.mData = blob;
 
   nsRefPtr<BlobEvent> event = BlobEvent::Constructor(this,
                                                      NS_LITERAL_STRING("picture"),
                                                      eventInit);
 
   DispatchTrustedEvent(event);
 }
 
 void
 nsDOMCameraControl::OnUserError(CameraControlListener::UserContext aContext, nsresult aError)
 {
+  DOM_CAMERA_LOGI("DOM OnUserError aContext=%u, aError=0x%x\n", aContext, aError);
   MOZ_ASSERT(NS_IsMainThread());
 
   nsRefPtr<Promise> promise;
-  nsRefPtr<CameraErrorCallback> errorCb;
 
   switch (aContext) {
     case CameraControlListener::kInStartCamera:
       promise = mGetCameraPromise.forget();
-      mGetCameraOnSuccessCb = nullptr;
-      errorCb = mGetCameraOnErrorCb.forget();
       break;
 
     case CameraControlListener::kInStopCamera:
       promise = mReleasePromise.forget();
-      errorCb = mReleaseOnErrorCb.forget();
       if (aError == NS_ERROR_NOT_INITIALIZED) {
         // This value indicates that the hardware is already closed; which for
         // kInStopCamera, is not actually an error.
         if (promise) {
           promise->MaybeResolve(JS::UndefinedHandleValue);
         }
 
-        nsRefPtr<CameraReleaseCallback> cb = mReleaseOnSuccessCb.forget();
-        mReleaseOnErrorCb = nullptr;
-        if (cb) {
-          ErrorResult ignored;
-          cb->Call(ignored);
-        }
-
         return;
       }
-      mReleaseOnSuccessCb = nullptr;
       break;
 
     case CameraControlListener::kInSetConfiguration:
       promise = mSetConfigurationPromise.forget();
-      mSetConfigurationOnSuccessCb = nullptr;
-      errorCb = mSetConfigurationOnErrorCb.forget();
       break;
 
     case CameraControlListener::kInAutoFocus:
       promise = mAutoFocusPromise.forget();
-      mAutoFocusOnSuccessCb = nullptr;
-      errorCb = mAutoFocusOnErrorCb.forget();
       DispatchStateEvent(NS_LITERAL_STRING("focus"), NS_LITERAL_STRING("unfocused"));
       break;
 
     case CameraControlListener::kInTakePicture:
       promise = mTakePicturePromise.forget();
-      mTakePictureOnSuccessCb = nullptr;
-      errorCb = mTakePictureOnErrorCb.forget();
       break;
 
     case CameraControlListener::kInStartRecording:
       promise = mStartRecordingPromise.forget();
-      mStartRecordingOnSuccessCb = nullptr;
-      errorCb = mStartRecordingOnErrorCb.forget();
       break;
 
     case CameraControlListener::kInStartFaceDetection:
       // This method doesn't have any callbacks, so all we can do is log the
       // failure. This only happens after the hardware has been released.
       NS_WARNING("Failed to start face detection");
       return;
 
@@ -1691,62 +1359,16 @@ nsDOMCameraControl::OnUserError(CameraCo
       {
         nsPrintfCString msg("Unhandled aContext=%u, aError=0x%x\n", aContext, aError);
         NS_WARNING(msg.get());
       }
       MOZ_ASSERT_UNREACHABLE("Unhandled user error");
       return;
   }
 
-  if (!promise && !errorCb) {
+  if (!promise) {
     DOM_CAMERA_LOGW("DOM No error handler for aError=0x%x in aContext=%u\n",
       aError, aContext);
     return;
   }
 
-  DOM_CAMERA_LOGI("DOM OnUserError aContext=%u, aError=0x%x\n", aContext, aError);
-  if (promise) {
-    promise->MaybeReject(aError);
-  }
-
-  if (errorCb) {
-    nsString error;
-    switch (aError) {
-      case NS_ERROR_INVALID_ARG:
-        error = NS_LITERAL_STRING("InvalidArgument");
-        break;
-
-      case NS_ERROR_NOT_AVAILABLE:
-        error = NS_LITERAL_STRING("NotAvailable");
-        break;
-
-      case NS_ERROR_NOT_IMPLEMENTED:
-        error = NS_LITERAL_STRING("NotImplemented");
-        break;
-
-      case NS_ERROR_NOT_INITIALIZED:
-        error = NS_LITERAL_STRING("HardwareClosed");
-        break;
-
-      case NS_ERROR_ALREADY_INITIALIZED:
-        error = NS_LITERAL_STRING("HardwareAlreadyOpen");
-        break;
-
-      case NS_ERROR_OUT_OF_MEMORY:
-        error = NS_LITERAL_STRING("OutOfMemory");
-        break;
-
-      default:
-        {
-          nsPrintfCString msg("Reporting aError=0x%x as generic\n", aError);
-          NS_WARNING(msg.get());
-        }
-        // fallthrough
-
-      case NS_ERROR_FAILURE:
-        error = NS_LITERAL_STRING("GeneralFailure");
-        break;
-    }
-
-    ErrorResult ignored;
-    errorCb->Call(error, ignored);
-  }
+  promise->MaybeReject(aError);
 }
--- a/dom/camera/DOMCameraControl.h
+++ b/dom/camera/DOMCameraControl.h
@@ -50,18 +50,16 @@ public:
   // classname, we can't rely on the [Func="..."] WebIDL tag to implicitly
   // include the right header for us; instead we must explicitly include a
   // HasSupport() method in each header. We can get rid of these with the
   // Great Renaming proposed in bug 983177.
   static bool HasSupport(JSContext* aCx, JSObject* aGlobal);
 
   nsDOMCameraControl(uint32_t aCameraId,
                      const dom::CameraConfiguration& aInitialConfig,
-                     dom::GetCameraCallback* aOnSuccess,
-                     dom::CameraErrorCallback* aOnError,
                      dom::Promise* aPromise,
                      nsPIDOMWindow* aWindow);
 
   void Shutdown();
 
   nsPIDOMWindow* GetParentObject() const { return mWindow; }
 
   // Attributes.
@@ -85,65 +83,39 @@ public:
   double GetExposureCompensation(ErrorResult& aRv);
   int32_t SensorAngle();
   already_AddRefed<dom::CameraCapabilities> Capabilities();
   void GetIsoMode(nsString& aMode, ErrorResult& aRv);
   void SetIsoMode(const nsAString& aMode, ErrorResult& aRv);
   double GetPictureQuality(ErrorResult& aRv);
   void SetPictureQuality(double aQuality, ErrorResult& aRv);
 
-  // Unsolicited event handlers.
-  dom::CameraShutterCallback* GetOnShutter();
-  void SetOnShutter(dom::CameraShutterCallback* aCb);
-  dom::CameraClosedCallback* GetOnClosed();
-  void SetOnClosed(dom::CameraClosedCallback* aCb);
-  dom::CameraRecorderStateChange* GetOnRecorderStateChange();
-  void SetOnRecorderStateChange(dom::CameraRecorderStateChange* aCb);
-  dom::CameraPreviewStateChange* GetOnPreviewStateChange();
-  void SetOnPreviewStateChange(dom::CameraPreviewStateChange* aCb);
-  dom::CameraAutoFocusMovingCallback* GetOnAutoFocusMoving();
-  void SetOnAutoFocusMoving(dom::CameraAutoFocusMovingCallback* aCb);
-  dom::CameraAutoFocusCallback* GetOnAutoFocusCompleted();
-  void SetOnAutoFocusCompleted(dom::CameraAutoFocusCallback* aCb);
-  dom::CameraFaceDetectionCallback* GetOnFacesDetected();
-  void SetOnFacesDetected(dom::CameraFaceDetectionCallback* aCb);
-
   // Methods.
   already_AddRefed<dom::Promise> SetConfiguration(const dom::CameraConfiguration& aConfiguration,
-                                                  const dom::Optional<dom::OwningNonNull<dom::CameraSetConfigurationCallback> >& aOnSuccess,
-                                                  const dom::Optional<dom::OwningNonNull<dom::CameraErrorCallback> >& aOnError,
                                                   ErrorResult& aRv);
   void GetMeteringAreas(nsTArray<dom::CameraRegion>& aAreas, ErrorResult& aRv);
   void SetMeteringAreas(const dom::Optional<dom::Sequence<dom::CameraRegion> >& aAreas, ErrorResult& aRv);
   void GetFocusAreas(nsTArray<dom::CameraRegion>& aAreas, ErrorResult& aRv);
   void SetFocusAreas(const dom::Optional<dom::Sequence<dom::CameraRegion> >& aAreas, ErrorResult& aRv);
   void GetPictureSize(dom::CameraSize& aSize, ErrorResult& aRv);
   void SetPictureSize(const dom::CameraSize& aSize, ErrorResult& aRv);
   void GetThumbnailSize(dom::CameraSize& aSize, ErrorResult& aRv);
   void SetThumbnailSize(const dom::CameraSize& aSize, ErrorResult& aRv);
-  already_AddRefed<dom::Promise> AutoFocus(const dom::Optional<dom::OwningNonNull<dom::CameraAutoFocusCallback> >& aOnSuccess,
-                                           const dom::Optional<dom::OwningNonNull<dom::CameraErrorCallback> >& aOnError,
-                                           ErrorResult& aRv);
+  already_AddRefed<dom::Promise> AutoFocus(ErrorResult& aRv);
   void StartFaceDetection(ErrorResult& aRv);
   void StopFaceDetection(ErrorResult& aRv);
   already_AddRefed<dom::Promise> TakePicture(const dom::CameraPictureOptions& aOptions,
-                                             const dom::Optional<dom::OwningNonNull<dom::CameraTakePictureCallback> >& aOnSuccess,
-                                             const dom::Optional<dom::OwningNonNull<dom::CameraErrorCallback> >& aOnError,
                                              ErrorResult& aRv);
   already_AddRefed<dom::Promise> StartRecording(const dom::CameraStartRecordingOptions& aOptions,
                                                 nsDOMDeviceStorage& storageArea,
                                                 const nsAString& filename,
-                                                const dom::Optional<dom::OwningNonNull<dom::CameraStartRecordingCallback> >& aOnSuccess,
-                                                const dom::Optional<dom::OwningNonNull<dom::CameraErrorCallback> >& aOnError,
                                                 ErrorResult& aRv);
   void StopRecording(ErrorResult& aRv);
   void ResumePreview(ErrorResult& aRv);
-  already_AddRefed<dom::Promise> ReleaseHardware(const dom::Optional<dom::OwningNonNull<dom::CameraReleaseCallback> >& aOnSuccess,
-                                                 const dom::Optional<dom::OwningNonNull<dom::CameraErrorCallback> >& aOnError,
-                                                 ErrorResult& aRv);
+  already_AddRefed<dom::Promise> ReleaseHardware(ErrorResult& aRv);
   void ResumeContinuousFocus(ErrorResult& aRv);
 
   virtual JSObject* WrapObject(JSContext* aCx) MOZ_OVERRIDE;
 
 #ifdef MOZ_WIDGET_GONK
   static void PreinitCameraHardware();
   static void DiscardCachedCameraInstance(nsITimer* aTimer, void* aClosure);
 #endif
@@ -218,39 +190,16 @@ protected:
   // camera control pending promises
   nsRefPtr<dom::Promise>                        mGetCameraPromise;
   nsRefPtr<dom::Promise>                        mAutoFocusPromise;
   nsRefPtr<dom::Promise>                        mTakePicturePromise;
   nsRefPtr<dom::Promise>                        mStartRecordingPromise;
   nsRefPtr<dom::Promise>                        mReleasePromise;
   nsRefPtr<dom::Promise>                        mSetConfigurationPromise;
 
-  // solicited camera control event handlers
-  nsRefPtr<dom::GetCameraCallback>              mGetCameraOnSuccessCb;
-  nsRefPtr<dom::CameraErrorCallback>            mGetCameraOnErrorCb;
-  nsRefPtr<dom::CameraAutoFocusCallback>        mAutoFocusOnSuccessCb;
-  nsRefPtr<dom::CameraErrorCallback>            mAutoFocusOnErrorCb;
-  nsRefPtr<dom::CameraTakePictureCallback>      mTakePictureOnSuccessCb;
-  nsRefPtr<dom::CameraErrorCallback>            mTakePictureOnErrorCb;
-  nsRefPtr<dom::CameraStartRecordingCallback>   mStartRecordingOnSuccessCb;
-  nsRefPtr<dom::CameraErrorCallback>            mStartRecordingOnErrorCb;
-  nsRefPtr<dom::CameraReleaseCallback>          mReleaseOnSuccessCb;
-  nsRefPtr<dom::CameraErrorCallback>            mReleaseOnErrorCb;
-  nsRefPtr<dom::CameraSetConfigurationCallback> mSetConfigurationOnSuccessCb;
-  nsRefPtr<dom::CameraErrorCallback>            mSetConfigurationOnErrorCb;
-
-  // unsolicited event handlers
-  nsRefPtr<dom::CameraShutterCallback>          mOnShutterCb;
-  nsRefPtr<dom::CameraClosedCallback>           mOnClosedCb;
-  nsRefPtr<dom::CameraRecorderStateChange>      mOnRecorderStateChangeCb;
-  nsRefPtr<dom::CameraPreviewStateChange>       mOnPreviewStateChangeCb;
-  nsRefPtr<dom::CameraAutoFocusMovingCallback>  mOnAutoFocusMovingCb;
-  nsRefPtr<dom::CameraAutoFocusCallback>        mOnAutoFocusCompletedCb;
-  nsRefPtr<dom::CameraFaceDetectionCallback>    mOnFacesDetectedCb;
-
   // Camera event listener; we only need this weak reference so that
   //  we can remove the listener from the camera when we're done
   //  with it.
   DOMCameraControlListener* mListener;
 
   // our viewfinder stream
   nsRefPtr<CameraPreviewMediaStream> mInput;
 
--- a/dom/camera/DOMCameraManager.cpp
+++ b/dom/camera/DOMCameraManager.cpp
@@ -139,52 +139,40 @@ public:
   NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(CameraPermissionRequest,
                                            nsIContentPermissionRequest)
 
   CameraPermissionRequest(nsIPrincipal* aPrincipal,
                           nsPIDOMWindow* aWindow,
                           nsRefPtr<nsDOMCameraManager> aManager,
                           uint32_t aCameraId,
                           const CameraConfiguration& aInitialConfig,
-                          nsRefPtr<GetCameraCallback> aOnSuccess,
-                          nsRefPtr<CameraErrorCallback> aOnError,
                           nsRefPtr<Promise> aPromise)
     : mPrincipal(aPrincipal)
     , mWindow(aWindow)
     , mCameraManager(aManager)
     , mCameraId(aCameraId)
     , mInitialConfig(aInitialConfig)
-    , mOnSuccess(aOnSuccess)
-    , mOnError(aOnError)
     , mPromise(aPromise)
-  {
-  }
+  { }
 
 protected:
-  virtual ~CameraPermissionRequest()
-  {
-  }
+  virtual ~CameraPermissionRequest() { }
 
   nsresult DispatchCallback(uint32_t aPermission);
   void CallAllow();
   void CallCancel();
   nsCOMPtr<nsIPrincipal> mPrincipal;
   nsCOMPtr<nsPIDOMWindow> mWindow;
   nsRefPtr<nsDOMCameraManager> mCameraManager;
   uint32_t mCameraId;
   CameraConfiguration mInitialConfig;
-  nsRefPtr<GetCameraCallback> mOnSuccess;
-  nsRefPtr<CameraErrorCallback> mOnError;
   nsRefPtr<Promise> mPromise;
 };
 
-NS_IMPL_CYCLE_COLLECTION(CameraPermissionRequest, mWindow,
-                                                  mOnSuccess,
-                                                  mOnError,
-                                                  mPromise)
+NS_IMPL_CYCLE_COLLECTION(CameraPermissionRequest, mWindow, mPromise)
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(CameraPermissionRequest)
   NS_INTERFACE_MAP_ENTRY(nsIContentPermissionRequest)
   NS_INTERFACE_MAP_ENTRY(nsIRunnable)
   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIContentPermissionRequest)
 NS_INTERFACE_MAP_END
 
 NS_IMPL_CYCLE_COLLECTING_ADDREF(CameraPermissionRequest)
@@ -240,23 +228,23 @@ CameraPermissionRequest::DispatchCallbac
     callbackRunnable = NS_NewRunnableMethod(this, &CameraPermissionRequest::CallCancel);
   }
   return NS_DispatchToMainThread(callbackRunnable);
 }
 
 void
 CameraPermissionRequest::CallAllow()
 {
-  mCameraManager->PermissionAllowed(mCameraId, mInitialConfig, mOnSuccess, mOnError, mPromise);
+  mCameraManager->PermissionAllowed(mCameraId, mInitialConfig, mPromise);
 }
 
 void
 CameraPermissionRequest::CallCancel()
 {
-  mCameraManager->PermissionCancelled(mCameraId, mInitialConfig, mOnSuccess, mOnError, mPromise);
+  mCameraManager->PermissionCancelled(mCameraId, mInitialConfig, mPromise);
 }
 
 NS_IMETHODIMP
 CameraPermissionRequest::GetTypes(nsIArray** aTypes)
 {
   nsTArray<nsString> emptyOptions;
   return nsContentPermissionUtils::CreatePermissionArray(NS_LITERAL_CSTRING("camera"),
                                                          NS_LITERAL_CSTRING("unused"),
@@ -270,18 +258,16 @@ nsDOMCameraManager::PreinitCameraHardwar
 {
   nsDOMCameraControl::PreinitCameraHardware();
 }
 #endif
 
 already_AddRefed<Promise>
 nsDOMCameraManager::GetCamera(const nsAString& aCamera,
                               const CameraConfiguration& aInitialConfig,
-                              const OptionalNonNullGetCameraCallback& aOnSuccess,
-                              const OptionalNonNullCameraErrorCallback& aOnError,
                               ErrorResult& aRv)
 {
   DOM_CAMERA_LOGT("%s:%d\n", __func__, __LINE__);
 
   uint32_t cameraId = 0;  // back (or forward-facing) camera by default
   if (aCamera.EqualsLiteral("front")) {
     cameraId = 1;
   }
@@ -292,86 +278,67 @@ nsDOMCameraManager::GetCamera(const nsAS
     return nullptr;
   }
 
   nsRefPtr<Promise> promise = Promise::Create(global, aRv);
   if (aRv.Failed()) {
     return nullptr;
   }
 
-  nsRefPtr<GetCameraCallback> successCallback;
-  if (aOnSuccess.WasPassed()) {
-    successCallback = &aOnSuccess.Value();
-  }
-
-  nsRefPtr<CameraErrorCallback> errorCallback;
-  if (aOnError.WasPassed()) {
-    errorCallback = &aOnError.Value();
-  }
-
   if (mPermission == nsIPermissionManager::ALLOW_ACTION) {
-    PermissionAllowed(cameraId, aInitialConfig, successCallback, errorCallback, promise);
+    PermissionAllowed(cameraId, aInitialConfig, promise);
     return promise.forget();
   }
 
   nsCOMPtr<nsIScriptObjectPrincipal> sop = do_QueryInterface(mWindow);
   if (!sop) {
     aRv.Throw(NS_ERROR_UNEXPECTED);
     return nullptr;
   }
 
   nsCOMPtr<nsIPrincipal> principal = sop->GetPrincipal();
   // If we are a CERTIFIED app, we can short-circuit the permission check,
   // which gets us a performance win.
   uint16_t status = nsIPrincipal::APP_STATUS_NOT_INSTALLED;
   principal->GetAppStatus(&status);
   if (status == nsIPrincipal::APP_STATUS_CERTIFIED && CheckPermission(mWindow)) {
-    PermissionAllowed(cameraId, aInitialConfig, successCallback, errorCallback, promise);
+    PermissionAllowed(cameraId, aInitialConfig, promise);
     return promise.forget();
   }
 
   nsCOMPtr<nsIRunnable> permissionRequest =
-    new CameraPermissionRequest(principal, mWindow, this, cameraId, aInitialConfig,
-                                successCallback, errorCallback, promise);
+    new CameraPermissionRequest(principal, mWindow, this, cameraId,
+                                aInitialConfig, promise);
 
   NS_DispatchToMainThread(permissionRequest);
   return promise.forget();
 }
 
 void
 nsDOMCameraManager::PermissionAllowed(uint32_t aCameraId,
                                       const CameraConfiguration& aInitialConfig,
-                                      GetCameraCallback* aOnSuccess,
-                                      CameraErrorCallback* aOnError,
                                       Promise* aPromise)
 {
   mPermission = nsIPermissionManager::ALLOW_ACTION;
 
   // Creating this object will trigger the aOnSuccess callback
   //  (or the aOnError one, if it fails).
   nsRefPtr<nsDOMCameraControl> cameraControl =
-    new nsDOMCameraControl(aCameraId, aInitialConfig, aOnSuccess, aOnError, aPromise, mWindow);
+    new nsDOMCameraControl(aCameraId, aInitialConfig, aPromise, mWindow);
 
   Register(cameraControl);
 }
 
 void
 nsDOMCameraManager::PermissionCancelled(uint32_t aCameraId,
                                         const CameraConfiguration& aInitialConfig,
-                                        GetCameraCallback* aOnSuccess,
-                                        CameraErrorCallback* aOnError,
                                         Promise* aPromise)
 {
   mPermission = nsIPermissionManager::DENY_ACTION;
-
   aPromise->MaybeReject(NS_ERROR_DOM_SECURITY_ERR);
-  if (aOnError) {
-    ErrorResult ignored;
-    aOnError->Call(NS_LITERAL_STRING("Permission denied."), ignored);
-  }
 }
 
 void
 nsDOMCameraManager::Register(nsDOMCameraControl* aDOMCameraControl)
 {
   DOM_CAMERA_LOGI(">>> Register( aDOMCameraControl = %p ) mWindowId = 0x%" PRIx64 "\n", aDOMCameraControl, mWindowId);
   MOZ_ASSERT(NS_IsMainThread());
 
--- a/dom/camera/DOMCameraManager.h
+++ b/dom/camera/DOMCameraManager.h
@@ -21,27 +21,21 @@
 
 class nsPIDOMWindow;
 
 namespace mozilla {
   class ErrorResult;
   class nsDOMCameraControl;
   namespace dom {
     struct CameraConfiguration;
-    class GetCameraCallback;
-    class CameraErrorCallback;
   }
 }
 
 typedef nsTArray<nsRefPtr<mozilla::nsDOMCameraControl> > CameraControls;
 typedef nsClassHashtable<nsUint64HashKey, CameraControls> WindowTable;
-typedef mozilla::dom::Optional<mozilla::dom::OwningNonNull<mozilla::dom::GetCameraCallback> >
-          OptionalNonNullGetCameraCallback;
-typedef mozilla::dom::Optional<mozilla::dom::OwningNonNull<mozilla::dom::CameraErrorCallback> >
-          OptionalNonNullCameraErrorCallback;
 
 class nsDOMCameraManager MOZ_FINAL
   : public nsIObserver
   , public nsSupportsWeakReference
   , public nsWrapperCache
 {
 public:
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
@@ -61,38 +55,31 @@ public:
     CreateInstance(nsPIDOMWindow* aWindow);
   static bool IsWindowStillActive(uint64_t aWindowId);
 
   void Register(mozilla::nsDOMCameraControl* aDOMCameraControl);
   void OnNavigation(uint64_t aWindowId);
 
   void PermissionAllowed(uint32_t aCameraId,
                          const mozilla::dom::CameraConfiguration& aOptions,
-                         mozilla::dom::GetCameraCallback* aOnSuccess,
-                         mozilla::dom::CameraErrorCallback* aOnError,
                          mozilla::dom::Promise* aPromise);
 
   void PermissionCancelled(uint32_t aCameraId,
                            const mozilla::dom::CameraConfiguration& aOptions,
-                           mozilla::dom::GetCameraCallback* aOnSuccess,
-                           mozilla::dom::CameraErrorCallback* aOnError,
                            mozilla::dom::Promise* aPromise);
 
   // WebIDL
   already_AddRefed<mozilla::dom::Promise>
   GetCamera(const nsAString& aCamera,
             const mozilla::dom::CameraConfiguration& aOptions,
-            const OptionalNonNullGetCameraCallback& aOnSuccess,
-            const OptionalNonNullCameraErrorCallback& aOnError,
             mozilla::ErrorResult& aRv);
   void GetListOfCameras(nsTArray<nsString>& aList, mozilla::ErrorResult& aRv);
 
   nsPIDOMWindow* GetParentObject() const { return mWindow; }
-  virtual JSObject* WrapObject(JSContext* aCx)
-    MOZ_OVERRIDE;
+  virtual JSObject* WrapObject(JSContext* aCx) MOZ_OVERRIDE;
 
 #ifdef MOZ_WIDGET_GONK
   static void PreinitCameraHardware();
 #endif
 
 protected:
   void XpComShutdown();
   void Shutdown(uint64_t aWindowId);
deleted file mode 100644
--- a/dom/camera/test/callback/test_bug1022766.html
+++ /dev/null
@@ -1,97 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-<head>
-  <title>Test for bug 1022766</title>
-  <script type="text/javascript" src="/MochiKit/MochiKit.js"></script>
-  <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
-  <script type="text/javascript" src="../camera_common.js"></script>
-  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
-</head>
-<body>
-<video id="viewfinder" width="200" height="200" autoplay></video>
-<img src="#" alt="This image is going to load" id="testimage"/>
-<script class="testbody" type="text/javascript;version=1.7">
-
-var whichCamera = navigator.mozCameras.getListOfCameras()[0];
-var config = {
-  mode: 'picture',
-  recorderProfile: 'cif',
-  previewSize: {
-    width: 352,
-    height: 288
-  }
-};
-
-function onError(e) {
-  ok(false, "Error" + JSON.stringify(e));
-}
-
-var Camera = {
-  cameraObj: null,
-  _otherPictureSize: null,
-  get viewfinder() {
-    return document.getElementById('viewfinder');
-  },
-
-  firstCallFailed: false,
-  secondCallSucceeded: false,
-  checkForDone: function test_checkForDone() {
-    if (Camera.firstCallFailed && Camera.secondCallSucceeded) {
-      Camera.cameraObj.release();
-      Camera.cameraObj = null;
-      CameraTest.end();
-    }
-  },
-
-  successOne: function test_successOne(focused) {
-    ok(false, "First call to autoFocus() succeeded unexpectedly");
-  },
-  failureOne: function test_failureOne(error) {
-    ok(error == "AutoFocusInterrupted", "First call to autoFocus() failed with: "
-      + error);
-    Camera.firstCallFailed = true;
-    Camera.checkForDone();
-  },
-  successTwo: function test_successTwo(focused) {
-    ok(true, "Second call to autoFocus() succeeded");
-    Camera.secondCallSucceeded = true;
-    Camera.checkForDone();
-  },
-  failureTwo: function test_failureTwo(error) {
-    ok(false, "Second call to autoFocus() failed unexpectedly with: " + error);
-  },
-
-  start: function test_start() {
-    function onSuccess(camera, config) {
-      Camera.cameraObj = camera;
-      Camera.viewfinder.mozSrcObject = camera;
-      Camera.viewfinder.play();
-
-      // It doesn't matter if the emulator supports focus or not;
-      // this is just testing the sequencing.
-      camera.autoFocus(Camera.successOne, Camera.failureOne);
-      camera.autoFocus(Camera.successTwo, Camera.failureTwo);
-    };
-
-    navigator.mozCameras.getCamera(whichCamera, config, onSuccess, onError);
-  }
-}
-
-window.addEventListener('beforeunload', function() {
-  Camera.viewfinder.mozSrcObject = null;
-  if (Camera.cameraObj) {
-    Camera.cameraObj.release();
-    Camera.cameraObj = null;
-  }
-});
-
-CameraTest.begin("hardware", function(test) {
-  test.set("auto-focus-process-failure", function() {
-    Camera.start();
-  })
-});
-
-</script>
-</body>
-
-</html>
deleted file mode 100644
--- a/dom/camera/test/callback/test_bug1099390.html
+++ /dev/null
@@ -1,107 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-<head>
-  <title>Test for bug 1099390</title>
-  <script type="text/javascript" src="/MochiKit/MochiKit.js"></script>
-  <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
-  <script type="text/javascript" src="camera_common.js"></script>
-  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
-</head>
-<body>
-<video id="viewfinder" width="200" height="200" autoplay></video>
-<img src="#" alt="This image is going to load" id="testimage"/>
-<script class="testbody" type="text/javascript;version=1.7">
-
-var whichCamera = navigator.mozCameras.getListOfCameras()[0];
-var config = {
-  mode: 'picture',
-  recorderProfile: 'cif',
-  previewSize: {
-    width: 352,
-    height: 288
-  }
-};
-
-function onError(e) {
-  ok(false, "Error " + e);
-}
-
-var Camera = {
-  _cameraObj: null,
-
-  get viewfinder() {
-    return document.getElementById('viewfinder');
-  },
-
-  release: function release() {
-    viewfinder.mozSrcObject = null;
-    if (Camera._cameraObj) {
-      Camera._cameraObj.release();
-      Camera._cameraObj = null;
-    }
-  },
-
-  test: function test(cam) {
-    var gotCloseEvent = false;
-    var gotReleaseCallback = false;
-
-    function gotAll() {
-      var all = gotCloseEvent && gotReleaseCallback;
-      if (all) {
-        info("Got all expected notifications");
-      }
-      return all;
-    };
-
-    cam.onClosed = function(reason) {
-      cam.onClosed = null;
-      ok(!gotCloseEvent, "gotCloseEvent was " + gotCloseEvent);
-      ok(reason === "HardwareReleased", "onClosed reason is: " + reason);
-      gotCloseEvent = true;
-      if (gotAll()) {
-        SimpleTest.finish();
-      }
-    };
-
-    var onSuccess = function() {
-      ok(!gotReleaseCallback, "gotReleaseCallback was " + gotReleaseCallback);
-      gotReleaseCallback = true;
-      if (gotAll()) {
-        SimpleTest.finish();
-      }
-    };
-
-    cam.release(onSuccess, onError);
-  }, // test()
-
-  start: function start() {
-    function onSuccess(cam) {
-      Camera._cameraObj = cam;
-      Camera.viewfinder.mozSrcObject = cam;
-      Camera.viewfinder.play();
-
-      var onPreviewStateChange = function(e) {
-        if (e.newState === 'started') {
-          cam.removeEventListener('previewstatechange', onPreviewStateChange);
-          Camera.test(cam);
-        }
-      }; // onPreviewStateChange
-      cam.addEventListener('previewstatechange', onPreviewStateChange);
-    }; // onSuccess()
-
-    navigator.mozCameras.getCamera(whichCamera, config, onSuccess, onError);
-  }, // start()
-}
-
-SimpleTest.waitForExplicitFinish();
-
-window.addEventListener('beforeunload', function() {
-  Camera.release();
-});
-
-Camera.start();
-
-</script>
-</body>
-
-</html>
deleted file mode 100644
--- a/dom/camera/test/callback/test_bug975472.html
+++ /dev/null
@@ -1,223 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-<head>
-  <title>Test for bug 975472</title>
-  <script type="text/javascript" src="/MochiKit/MochiKit.js"></script>
-  <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
-  <script type="text/javascript" src="../camera_common.js"></script>
-  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
-</head>
-<body>
-<video id="viewfinder" width="200" height="200" autoplay></video>
-<img src="#" alt="This image is going to load" id="testimage"/>
-<script class="testbody" type="text/javascript;version=1.7">
-
-var whichCamera = navigator.mozCameras.getListOfCameras()[0];
-var config = {
-  mode: 'picture',
-  recorderProfile: 'cif',
-  previewSize: {
-    width: 352,
-    height: 288
-  }
-};
-var options = {
-  rotation: 0,
-  position: {
-    latitude: 43.645687,
-    longitude: -79.393661
-  },
-  dateTime: Date.now()
-};
-
-function onError(e) {
-  ok(false, "Error" + JSON.stringify(e));
-}
-function next() {
-  Camera.nextTest();
-}
-
-// The array of tests
-var tests = [
-  {
-    key: "release-after-release",
-    func: function testAutoFocus(camera) {
-      function onSuccess(success) {
-        ok(true, "release() succeeded");
-        next();
-      }
-      function onError(error) {
-        ok(false, "release() failed with: " + error);
-      }
-      camera.release(onSuccess, onError);
-    }
-  },
-  {
-    key: "set-picture-size-after-release",
-    func: function testSetPictureSize(camera) {
-      camera.setPictureSize({ width: 0, height: 0 });
-      next();
-    }
-  },
-  {
-    key: "set-thumbnail-size-after-release",
-    func: function testSetThumbnailSize(camera) {
-      camera.setThumbnailSize({ width: 0, height: 0 });
-      next();
-    }
-  },
-  {
-    key: "get-sensor-angle-after-release",
-    func: function testGetSensorAngle(camera) {
-      ok(camera.sensorAngle == 0, "camera.sensorAngle = " + camera.sensorAngle);
-      next();
-    }
-  },
-  {
-    key: "resume-preview-after-release",
-    func: function testResumePreview(camera) {
-      camera.resumePreview();
-      next();
-    }
-  },
-  {
-    key: "auto-focus-after-release",
-    func: function testAutoFocus(camera) {
-      function onSuccess(success) {
-        ok(false, "autoFocus() succeeded incorrectly");
-      }
-      function onError(error) {
-        ok(error === "HardwareClosed", "autoFocus() failed with: " + error);
-        next();
-      }
-      camera.autoFocus(onSuccess, onError);
-    }
-  },
-  {
-    key: "take-picture-after-release",
-    func: function testTakePicture(camera) {
-      function onSuccess(picture) {
-        ok(false, "takePicture() succeeded incorrectly");
-      }
-      function onError(error) {
-        ok(error === "HardwareClosed", "takePicture() failed with: " + error);
-        next();
-      }
-      camera.takePicture(null, onSuccess, onError);
-    }
-  },
-  {
-    key: "start-recording-after-release",
-    func: function testStartRecording(camera) {
-      function onSuccess(picture) {
-        ok(false, "startRecording() process succeeded incorrectly");
-      }
-      function onError(error) {
-        ok(error === "GeneralFailure", "startRecording() failed with: " + error);
-        next();
-      }
-      var recordingOptions = {
-        profile: 'cif',
-        rotation: 0
-      };
-      camera.startRecording(recordingOptions,
-                            navigator.getDeviceStorage('videos'),
-                            'bug975472.mp4',
-                            onSuccess, onError);
-    }
-  },
-  {
-    key: "stop-recording-after-release",
-    func: function testStopRecording(camera) {
-      camera.stopRecording();
-      next();
-    }
-  },
-  {
-    key: "set-configuration-after-release",
-    func: function testSetConfiguration(camera) {
-      function onSuccess(picture) {
-        ok(false, "setConfiguration() process succeeded incorrectly");
-      }
-      function onError(error) {
-        ok(error === "HardwareClosed", "setConfiguration() failed with: " + error);
-        next();
-      }
-      camera.setConfiguration(config, onSuccess, onError);
-    }
-  },
-];
-
-var testGenerator = function() {
-  for (var i = 0; i < tests.length; ++i ) {
-    yield tests[i];
-  }
-}();
-
-var Camera = {
-  cameraObj: null,
-  _otherPictureSize: null,
-  get viewfinder() {
-    return document.getElementById('viewfinder');
-  },
-  onCameraReady: function () {
-    Camera.nextTest = function() {
-      try {
-        var t = testGenerator.next();
-        info("test: " + t.key);
-        t.func(Camera.cameraObj);
-      } catch(e) {
-        if (e instanceof StopIteration) {
-          CameraTest.end();
-        } else {
-          throw e;
-        }
-      }
-    };
-    // Release the camera hardware, and call all of the asynchronous methods
-    // to make sure they properly handle being in this state.
-    Camera.cameraObj.release();
-    next();
-  },
-  release: function release() {
-    cameraObj = null;
-  },
-  start: function run_test() {
-    function onSuccess(camera, config) {
-      Camera.cameraObj = camera;
-      Camera.viewfinder.mozSrcObject = camera;
-      Camera.viewfinder.play();
-      ok(camera.capabilities.pictureSizes.length > 0,
-        "capabilities.pictureSizes.length = " +
-        camera.capabilities.pictureSizes.length);
-      Camera._otherPictureSize = camera.capabilities.pictureSizes.slice(-1)[0];
-      camera.setPictureSize(camera.capabilities.pictureSizes[0]);
-      options.pictureSize = Camera._otherPictureSize;
-      options.fileFormat = camera.capabilities.fileFormats[0];
-      info("getCamera callback, setting pictureSize = " + options.pictureSize.toSource());
-      Camera.cameraObj.onPreviewStateChange = function(state) {
-        if (state === 'started') {
-          info("viewfinder is ready and playing");
-          Camera.cameraObj.onPreviewStateChange = null;
-          Camera.onCameraReady();
-        }
-      };
-    };
-    navigator.mozCameras.getCamera(whichCamera, config, onSuccess, onError);
-  }
-}
-
-SimpleTest.waitForExplicitFinish();
-
-window.addEventListener('beforeunload', function() {
-  Camera.viewfinder.mozSrcObject = null;
-  Camera.cameraObj.release();
-  Camera.cameraObj = null;
-});
-
-Camera.start();
-
-</script>
-</body>
-
-</html>
deleted file mode 100644
--- a/dom/camera/test/callback/test_camera.html
+++ /dev/null
@@ -1,242 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-<head>
-  <title>Test for mozCameras.getCamera() with separate .setConfiguration() call</title>
-  <script type="text/javascript" src="/MochiKit/MochiKit.js"></script>
-  <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
-  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
-</head>
-<body>
-<video id="viewfinder" width="200" height="200" autoplay></video>
-<img src="#" alt="This image is going to load" id="testimage"/>
-<script class="testbody" type="text/javascript;version=1.7">
-
-var whichCamera = navigator.mozCameras.getListOfCameras()[0];
-var options = {
-  mode: 'picture',
-  recorderProfile: 'cif',
-  previewSize: {
-    width: 352,
-    height: 288
-  }
-};
-
-var config = {
-  dateTime: Date.now() / 1000,
-  pictureSize: null,
-  fileFormat: 'jpeg',
-  rotation: 90
-};
-
-function onError(e) {
-  ok(false, "Error" + JSON.stringify(e));
-}
-
-var capabilities = [ 'previewSizes', 'pictureSizes', 'fileFormats', 'maxFocusAreas', 'minExposureCompensation',
-                     'maxExposureCompensation', 'stepExposureCompensation', 'maxMeteringAreas', 'videoSizes',
-                     'recorderProfiles', 'zoomRatios', 'isoModes'];
-
-var Camera = {
-  cameraObj: null,
-  _recording: false,
-  _currentTest: null,
-  _autoFocusSupported: 0,
-  _manuallyFocused: false,
-  _flashmodes: null,
-  _pictureSizes: null,
-  _previewSizes: null,
-  _whiteBalanceModes: null,
-  _zoomRatios: null,
-  _sceneModes: null,
-  _focusModes: null,
-  _zoomRatios: null,
-  _testsCompleted: 0,
-  _shutter: 0,
-  _config: {
-    dateTime: Date.now() / 1000,
-    pictureSize: null,
-    fileFormat: 'jpeg',
-    rotation: 90
-  },
-  _tests: null,
-  get viewfinder() {
-    return document.getElementById('viewfinder');
-  },
-  setFlashMode: function camera_setFlash(mode) {
-    this.cameraObj.flashMode = mode;
-  },
-  setFocus: function camera_setfocus(mode) {
-    this.cameraObj.focus = mode;
-  },
-  setZoom: function camera_setZoom(zoom) {
-    this.cameraObj.zoom = zoom;
-  },
-  getZoom: function camera_getZoom() {
-    return this.cameraObj.zoom;
-  },
-  getFileFormats: function camera_formats() {
-    this._fileFormats = this.cameraObj.capabilities.fileFormats;
-  },
-  getFlashModes: function camera_getFlash() {
-    this._flashmodes = this.cameraObj.capabilities.flashModes;
-  },
-  getFocusModes: function camera_getFocus() {
-    this._focusModes = this.cameraObj.capabilities.focusModes;
-  },
-  getSceneModes: function camera_getScene() {
-    this._sceneModes = this.cameraObj.capabilities.sceneModes;
-  },
-  getZoomRatios: function camera_getZoom() {
-    this._zoomRatios = this.cameraObj.capabilities.zoomRatios;
-  },
-  getWhiteBalance: function camera_white() {
-    this._whitebalanceModes = this.cameraObj.capabilities.whiteBalanceModes;
-  },
-  getPictureSizes: function camera_sizes() {
-    this._pictureSizes = this.cameraObj.capabilities.pictureSizes;
-  },
-  getPreviewSizes: function camera_preview() {
-    this._previewSizes = this.cameraObj.capabilities.previewSizes;
-  },
-  getZoomRatios: function camera_preview() {
-    this._zoomRatios = this.cameraObj.capabilities.zoomRatios;
-  },
-  takePictureSuccess: function taken_foto(blob) {
-    var img = new Image();
-    var test = this._currentTest;
-    img.onload = function Imgsize() {
-      ok(this.width == test.pictureSize.width, "The image taken has the width " + 
-                                              this.width + " pictureSize width = " + test.pictureSize.width);
-      ok(this.height == test.pictureSize.height, "The image taken has the height " + 
-                                              this.height + " picturesize height = " + test.pictureSize.height);
-      Camera._testsCompleted++;
-      if(Camera._testsCompleted == Camera._tests.length) {
-        ok(true, "test finishing");
-        SimpleTest.finish();
-      } else {
-        Camera.runTests();
-      }
-    }
-    ok(blob.size > 100 , "Blob Size Gathered = " + blob.size);
-    ok("image/" + test.fileFormat ==  blob.type, "Blob Type = " + blob.type);
-    img.src = window.URL.createObjectURL(blob);
-  },
-  shutter: function onShutter () {
-    Camera._shutter++;
-    
-    ok(Camera._shutter == (Camera._testsCompleted + 1), "on Shutter has been called " +
-                           Camera._shutter + " times");
-
-  },
-  onReady: function onReady() {
-    var camcap = Camera.cameraObj.capabilities;
-    var tests = {};
-    for (var prop in capabilities) {
-      prop = capabilities[prop];
-      ok(camcap[prop] || isFinite(camcap[prop]) || camcap[prop] == null, "Camera Capability: " +
-                    prop + " is exposed, value = " + JSON.stringify(camcap[prop]));
-    }
-    ok(camcap.maxMeteringAreas >= 0, "maxMeteringAreas = " + camcap.maxMeteringAreas);
-    ok(camcap.maxFocusAreas >= 0, "maxFocusAreas = " + camcap.maxFocusAreas);
-    for (var prop in camcap) {
-      if(camcap[prop] && camcap[prop].length > 1)  {
-        tests[prop] = camcap[prop];
-      }
-    }
-    Camera.getPictureSizes();
-    Camera.getPreviewSizes();
-    Camera.getFileFormats();
-    Camera.getFocusModes();
-    Camera.getZoomRatios();
-    ok(Camera._previewSizes.length > 0, "previewSizes length = " + Camera._previewSizes.length);
-    ok(Camera._pictureSizes.length > 0, "picturesizes length = " + Camera._pictureSizes.length);
-    ok(Camera._fileFormats.length > 0, "file formats length = " + Camera._fileFormats.length);
-    ok(camcap.isoModes.length == 0, "ISO modes length = " + camcap.isoModes.length);
-
-    // The emulator doesn't support zoom, so these parameters will be very constrained
-    // For more ambitious tests, see test_camera_fake_parameters.html
-    ok(Camera._zoomRatios.length == 1, "zoom ratios length = " + Camera._zoomRatios.length);
-    ok(Camera.cameraObj.zoom == 1.0, "zoom = " + Camera.cameraObj.zoom);
-    // Test snapping to supported values
-    Camera.cameraObj.zoom = 0.9;
-    ok(Camera.cameraObj.zoom == 1.0, "zoom (lower limit) = " + Camera.cameraObj.zoom);
-    Camera.cameraObj.zoom = 1.1;
-    ok(Camera.cameraObj.zoom == 1.0, "zoom (upper limit) = " + Camera.cameraObj.zoom);
-
-    // Check image quality handling
-    Camera.cameraObj.pictureQuality = 0.0;
-    ok(Camera.cameraObj.pictureQuality == 0.0, "picture quality = " + Camera.cameraObj.pictureQuality);
-    Camera.cameraObj.pictureQuality = -0.1;
-    ok(Camera.cameraObj.pictureQuality == 0.0, "picture quality (minimum limit) = " + Camera.cameraObj.pictureQuality);
-    Camera.cameraObj.pictureQuality = -Math.pow(2, 80);
-    ok(Camera.cameraObj.pictureQuality == 0.0, "picture quality (BIG negative) = " + Camera.cameraObj.pictureQuality);
-    Camera.cameraObj.pictureQuality = 1.0;
-    ok(Camera.cameraObj.pictureQuality == 1.0, "picture quality = " + Camera.cameraObj.pictureQuality);
-    Camera.cameraObj.pictureQuality = 1.1;
-    ok(Camera.cameraObj.pictureQuality == 1.0, "picture quality (maximum limit) = " + Camera.cameraObj.pictureQuality);
-    Camera.cameraObj.pictureQuality = Math.pow(2, 80);
-    ok(Camera.cameraObj.pictureQuality == 1.0, "picture quality (BIG positive) = " + Camera.cameraObj.pictureQuality);
-
-    Camera._tests = new Array();
-    for (var i in Camera._pictureSizes) {
-      for (var l in Camera._fileFormats) {
-        var config = {
-          pictureSize: Camera._pictureSizes[i],
-          fileFormat: Camera._fileFormats[l]
-        };
-        Camera._tests.push(config);
-      }
-    }
-    Camera.runTests();
-  },
-  runTests: function run_tests() {
-    var test = this._tests[this._testsCompleted];
-    this._currentTest = test;
-    Camera.setFlashMode(test.flashMode);
-    config.fileFormat = test.fileFormat;
-    config.pictureSize = test.pictureSize;
-    ok(true, "testing picture size " + JSON.stringify(config.pictureSize));
-    Camera.cameraObj.takePicture(config, this.takePictureSuccess.bind(this), onError);
-  },
-  onConfigChange: function onConfigChange(config) {
-    ok(config.mode === options.mode, "configuration mode = " + config.mode);
-    ok(config.recorderProfile === options.recorderProfile, "recorder profile = " + config.recorderProfile);
-    ok(config.previewSize.width === options.previewSize.width &&
-      config.previewSize.height === options.previewSize.height,
-      "preview size (w x h) = " + config.previewSize.width + " x " + config.previewSize.height);
-  },
-  setUp: function setup_tests() {
-    function onSuccess(camera) {
-      Camera.cameraObj = camera;
-      Camera.viewfinder.mozSrcObject = camera;
-      Camera.viewfinder.play();
-      Camera.cameraObj.onPreviewStateChange = function(state) {
-        if (state === 'started') {
-          ok(true, "viewfinder is ready and playing");
-          Camera.cameraObj.onPreviewStateChange = null;
-          Camera.onReady();
-        }
-      };
-      SimpleTest.expectAssertions(0);
-      ok(true, "Camera Control object has been successfully initialized");
-      Camera.cameraObj.setConfiguration(options, Camera.onConfigChange, onError);
-      Camera.cameraObj.onShutter = Camera.shutter;
-    };
-    navigator.mozCameras.getCamera(whichCamera, null, onSuccess, onError);
-  }
-}
-
-SimpleTest.waitForExplicitFinish();
-
-window.addEventListener('beforeunload', function() {
-  Camera.viewfinder.mozSrcObject = null;
-  Camera.cameraObj.release();
-  Camera.cameraObj = null;
-});
-
-Camera.setUp();
-
-</script>
-</body>
-
-</html>
deleted file mode 100644
--- a/dom/camera/test/callback/test_camera_2.html
+++ /dev/null
@@ -1,200 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-<head>
-  <title>Test for mozCameras.getCamera() using an initial configuration</title>
-  <script type="text/javascript" src="/MochiKit/MochiKit.js"></script>
-  <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
-  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
-</head>
-<body>
-<video id="viewfinder" width="200" height="200" autoplay></video>
-<img src="#" alt="This image is going to load" id="testimage"/>
-<script class="testbody" type="text/javascript;version=1.7">
-
-var whichCamera = navigator.mozCameras.getListOfCameras()[0];
-var options = {
-  mode: 'picture',
-  recorderProfile: 'cif',
-  previewSize: {
-    width: 352,
-    height: 288
-  }
-};
-
-var config = {
-  dateTime: Date.now() / 1000,
-  pictureSize: null,
-  fileFormat: 'jpeg',
-  rotation: 90
-};
-
-function onError(e) {
-  ok(false, "Error" + JSON.stringify(e));
-}
-
-var capabilities = [ 'previewSizes', 'pictureSizes', 'fileFormats', 'maxFocusAreas', 'minExposureCompensation',
-                     'maxExposureCompensation', 'stepExposureCompensation', 'maxMeteringAreas', 'videoSizes',
-                     'recorderProfiles'];
-
-var Camera = {
-  cameraObj: null,
-  _recording: false,
-  _currentTest: null,
-  _autoFocusSupported: 0,
-  _manuallyFocused: false,
-  _flashmodes: null,
-  _pictureSizes: null,
-  _previewSizes: null,
-  _whiteBalanceModes: null,
-  _zoomRatios: null,
-  _sceneModes: null,
-  _focusModes: null,
-  _testsCompleted: 0,
-  _shutter: 0,
-  _config: {
-    dateTime: Date.now() / 1000,
-    pictureSize: null,
-    fileFormat: 'jpeg',
-    rotation: 90
-  },
-  _tests: null,
-  get viewfinder() {
-    return document.getElementById('viewfinder');
-  },
-  setFlashMode: function camera_setFlash(mode) {
-    this.cameraObj.flashMode = mode;
-  },
-  setFocus: function camera_setfocus(mode) {
-    this.cameraObj.focus = mode;
-  },
-  getFileFormats: function camera_formats() {
-    this._fileFormats = this.cameraObj.capabilities.fileFormats;
-  },
-  getFlashModes: function camera_getFlash() {
-    this._flashmodes = this.cameraObj.capabilities.flashModes;
-  },
-  getFocusModes: function camera_getFocus() {
-    this._focusModes = this.cameraObj.capabilities.focusModes;
-  },
-  getSceneModes: function camera_getScene() {
-    this._sceneModes = this.cameraObj.capabilities.sceneModes;
-  },
-  getZoomRatios: function camera_getZoom() {
-    this._zoomRatios = this.cameraObj.capabilities.zoomRatios;
-  },
-  getWhiteBalance: function camera_white() {
-    this._whitebalanceModes = this.cameraObj.capabilities.whiteBalanceModes;
-  },
-  getPictureSizes: function camera_sizes() {
-    this._pictureSizes = this.cameraObj.capabilities.pictureSizes;
-  },
-  getPreviewSizes: function camera_preview() {
-    this._previewSizes = this.cameraObj.capabilities.previewSizes;
-  },
-  takePictureSuccess: function taken_foto(blob) {
-    var img = new Image();
-    var test = this._currentTest;
-    img.onload = function Imgsize() {
-      ok(this.width == test.pictureSize.width, "The image taken has the width " +
-                                              this.width + " pictureSize width = " + test.pictureSize.width);
-      ok(this.height == test.pictureSize.height, "The image taken has the height " +
-                                              this.height + " picturesize height = " + test.pictureSize.height);
-      Camera._testsCompleted++;
-      if(Camera._testsCompleted == Camera._tests.length) {
-        ok(true, "test finishing");
-        SimpleTest.finish();
-      } else {
-        Camera.runTests();
-      }
-    }
-    ok(blob.size > 100 , "Blob Size Gathered = " + blob.size);
-    ok("image/" + test.fileFormat ==  blob.type, "Blob Type = " + blob.type);
-    img.src = window.URL.createObjectURL(blob);
-  },
-  shutter: function onShutter () {
-    Camera._shutter++;
-    
-    ok(Camera._shutter == (Camera._testsCompleted + 1), "on Shutter has been called " +
-                           Camera._shutter + " times");
-
-  },
-  onReady: function onReady() {
-    var camcap = Camera.cameraObj.capabilities;
-    var tests = {};
-    for (var prop in capabilities) {
-      prop = capabilities[prop];
-      ok(camcap[prop] || isFinite(camcap[prop]) || camcap[prop] == null, "Camera Capability: " +
-                    prop + " is exposed, value = " + JSON.stringify(camcap[prop]));
-    } 
-    for (var prop in camcap) {
-      if(camcap[prop] && camcap[prop].length > 1)  {
-        tests[prop] = camcap[prop];
-      }
-    }
-    Camera.getPictureSizes();
-    Camera.getPreviewSizes();
-    Camera.getFileFormats();
-    Camera.getFocusModes();
-    ok(Camera._previewSizes.length > 0, "previewSizes length = " + Camera._previewSizes.length);
-    ok(Camera._pictureSizes.length > 0, "picturesizes length = " + Camera._pictureSizes.length);
-    ok(Camera._fileFormats.length > 0, "file formats length = " + Camera._fileFormats.length);
-    Camera._tests = new Array();
-    for (var i in Camera._pictureSizes) {
-      for (var l in Camera._fileFormats) {
-        var config = {
-          pictureSize: Camera._pictureSizes[i],
-          fileFormat: Camera._fileFormats[l]
-        };
-        Camera._tests.push(config);
-      }
-    }
-    Camera.runTests();
-  },
-  runTests: function run_tests() {
-    var test = this._tests[this._testsCompleted];
-    this._currentTest = test;
-    Camera.setFlashMode(test.flashMode);
-    config.fileFormat = test.fileFormat;
-    config.pictureSize = test.pictureSize;
-    ok(true, "testing picture size " + JSON.stringify(config.pictureSize));
-    Camera.cameraObj.takePicture(config, this.takePictureSuccess.bind(this), onError);
-  },
-  setUp: function setup_tests() {
-    function onSuccess(camera, config) {
-      ok(true, "Camera Control object has been successfully initialized");
-      ok(config.mode === options.mode, "configuration mode = " + config.mode);
-      ok(config.recorderProfile === options.recorderProfile, "recorder profile = " + config.recorderProfile);
-      ok(config.previewSize.width === options.previewSize.width &&
-        config.previewSize.height === options.previewSize.height,
-        "preview size (w x h) = " + config.previewSize.width + " x " + config.previewSize.height);
-      Camera.cameraObj = camera;
-      Camera.viewfinder.mozSrcObject = camera;
-      Camera.viewfinder.play();
-      Camera.cameraObj.onPreviewStateChange = function(state) {
-        if (state === 'started') {
-          ok(true, "viewfinder is ready and playing");
-          Camera.cameraObj.onPreviewStateChange = null;
-          Camera.onReady();
-        }
-      };
-      SimpleTest.expectAssertions(0);
-      Camera.cameraObj.onShutter = Camera.shutter;
-    };
-    navigator.mozCameras.getCamera(whichCamera, options, onSuccess, onError);
-  }
-}
-
-SimpleTest.waitForExplicitFinish();
-
-window.addEventListener('beforeunload', function() {
-  Camera.viewfinder.mozSrcObject = null;
-  Camera.cameraObj.release();
-  Camera.cameraObj = null;
-});
-
-Camera.setUp();
-
-</script>
-</body>
-
-</html>
deleted file mode 100644
--- a/dom/camera/test/callback/test_camera_3.html
+++ /dev/null
@@ -1,76 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-<head>
-  <title>Test for multiple calls to mozCameras.getCamera()</title>
-  <script type="text/javascript" src="/MochiKit/MochiKit.js"></script>
-  <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
-  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
-</head>
-<body>
-<video id="viewfinder" width="200" height="200" autoplay></video>
-<img src="#" alt="This image is going to load" id="testimage"/>
-<script class="testbody" type="text/javascript;version=1.7">
-
-var whichCamera = navigator.mozCameras.getListOfCameras()[0];
-var options = {
-  mode: 'picture',
-  recorderProfile: 'cif',
-  previewSize: {
-    width: 352,
-    height: 288
-  }
-};
-
-function onError(e) {
-  ok(false, "Error" + JSON.stringify(e));
-}
-
-var Camera = {
-  cameraObj: null,
-  get viewfinder() {
-    return document.getElementById('viewfinder');
-  },
-  onReady: function take_two() {
-    function onSuccess(camera, config) {
-      ok(false, "Unexpectedly got second camera instance: " + config.toSource);
-    }
-    function onFailure(error) {
-      ok(true, "Correctly failed to get camera again");
-      SimpleTest.finish();
-    }
-    navigator.mozCameras.getCamera(whichCamera, options, onSuccess, onFailure);
-  },
-  release: function release() {
-    cameraObj = null;
-  },
-  start: function run_test() {
-    function onSuccess(camera, config) {
-      Camera.cameraObj = camera;
-      Camera.viewfinder.mozSrcObject = camera;
-      Camera.viewfinder.play();
-      Camera.cameraObj.onPreviewStateChange = function(state) {
-        if (state === 'started') {
-          ok(true, "viewfinder is ready and playing");
-          Camera.cameraObj.onPreviewStateChange = null;
-          Camera.onReady();
-        }
-      };
-    };
-    navigator.mozCameras.getCamera(whichCamera, options, onSuccess, onError);
-  }
-}
-
-SimpleTest.waitForExplicitFinish();
-
-window.addEventListener('beforeunload', function() {
-  Camera.viewfinder.mozSrcObject = null;
-  Camera.cameraObj.release();
-  Camera.cameraObj = null;
-});
-
-Camera.start();
-
-</script>
-</body>
-
-</html>
deleted file mode 100644
--- a/dom/camera/test/callback/test_camera_hardware_auto_focus_moving_cb.html
+++ /dev/null
@@ -1,131 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-<!--
-https://bugzilla.mozilla.org/show_bug.cgi?id=965421
--->
-<head>
-  <title>Bug 965421 - Test camera hardware API for Auto focus moving Callback</title>
-  <script type="text/javascript" src="/MochiKit/MochiKit.js"></script>
-  <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
-  <script type="text/javascript" src="../camera_common.js"></script>
-  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
-</head>
-<body>
-  <a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=965421">Mozilla Bug 965421</a>
-  <video id="viewfinder" width = "200" height = "200" autoplay></video>
-  <img src="#" alt="This image is going to load" id="testimage"/>
-
-<script class="testbody" type="text/javascript;version=1.7">
-
-var whichCamera = navigator.mozCameras.getListOfCameras()[0];
-var initialConfig = {
-  mode: 'picture',
-  recorderProfile: 'cif',
-  previewSize: {
-    width: 352,
-    height: 288
-  }
-};
-
-const PREF_AUTOFOCUSCALLBACK_ENABLED = "camera.control.autofocus_moving_callback.enabled";
-
-var cameraObj;
-var oldPref;
-
-// Shorthand functions
-function end() {
-  function reallyEnd() {
-    CameraTest.end();
-  }
-  if (oldPref) {
-    SpecialPowers.pushPrefEnv(
-      {'set': [[PREF_AUTOFOCUSCALLBACK_ENABLED, oldPref]]}, reallyEnd);
-  } else {
-    SpecialPowers.pushPrefEnv(
-      {'clear': [[PREF_AUTOFOCUSCALLBACK_ENABLED]]}, reallyEnd);
-  }
-}
-function next() {
-  CameraTest.next();
-}
-
-var tests = [
-  {
-    key: "autofocus-moving-true",
-    func: function testAutoFocusMovingIsTrue(camera) {
-      camera.onAutoFocusMoving = function(aIsMoving) {
-        ok(aIsMoving == true,"onAutoFocusMoving callback received true correctly");
-        camera.focusMode = 'auto';
-        next();
-      }
-      camera.focusMode = 'continuous-picture';
-    }
-  },
-  {
-    key: "autofocus-moving-false",
-    func: function testAutoFocusMovingIsFalse(camera) {
-      camera.onAutoFocusMoving = function(aIsMoving) {
-        ok(aIsMoving == false, "onAutoFocusMoving callback received false correctly");
-        camera.focusMode = 'auto';
-        end();
-      }
-      camera.focusMode = 'continuous-video';
-    }
-  },
-];
-
-var testGenerator = function() {
-  for (var i = 0; i < tests.length; ++i ) {
-    yield tests[i];
-  }
-}();
-
-window.addEventListener('beforeunload', function() {
-  document.getElementById('viewfinder').mozSrcObject = null;
-  cameraObj.release();
-  cameraObj = null;
-});
-
-// Must call CameraTest.begin() before any other async methods.
-CameraTest.begin("hardware", function(test) {
-  // If the pref doesn't exist, this get will fail; catch it and continue.
-  try {
-    oldPref = SpecialPowers.getBoolPref(PREF_AUTOFOCUSCALLBACK_ENABLED);
-  } catch(e) { }
-
-  SpecialPowers.pushPrefEnv({'set': [[PREF_AUTOFOCUSCALLBACK_ENABLED, true]]}, function() {
-    var enabled;
-    try {
-      enabled = SpecialPowers.getBoolPref(PREF_AUTOFOCUSCALLBACK_ENABLED);
-    } catch(e) { }
-    ok(enabled, PREF_AUTOFOCUSCALLBACK_ENABLED + " is " + enabled);
-
-    function onSuccess(camera, config) {
-      document.getElementById('viewfinder').mozSrcObject = camera;
-      cameraObj = camera;
-      CameraTest.next = function() {
-        try {
-          var t = testGenerator.next();
-          test.set(t.key, t.func.bind(undefined, camera));
-        } catch(e) {
-          if (e instanceof StopIteration) {
-            end();
-          } else {
-            throw e;
-          }
-        }
-      };
-      next();
-    }
-    function onError(error) {
-      ok(false, "getCamera() failed with: " + error);
-      end();
-    }
-    navigator.mozCameras.getCamera(whichCamera, initialConfig, onSuccess, onError);
-  })
-});
-
-</script>
-</body>
-
-</html>
deleted file mode 100644
--- a/dom/camera/test/callback/test_camera_hardware_face_detection.html
+++ /dev/null
@@ -1,320 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-<!--
-https://bugzilla.mozilla.org/show_bug.cgi?id=965420
--->
-<head>
-  <title>Bug 965420 - Test camera hardware API for face detection</title>
-  <script type="text/javascript" src="/MochiKit/MochiKit.js"></script>
-  <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
-  <script type="text/javascript" src="../camera_common.js"></script>
-  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
-</head>
-<body>
-  <a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=965420">Mozilla Bug 965420</a>
-  <video id="viewfinder" width = "200" height = "200" autoplay></video>
-  <img src="#" alt="This image is going to load" id="testimage"/>
-
-<script class="testbody" type="text/javascript;version=1.7">
-
-var whichCamera = navigator.mozCameras.getListOfCameras()[0];
-var initialConfig = {
-  mode: 'picture',
-  recorderProfile: 'cif',
-  previewSize: {
-    width: 352,
-    height: 288
-  }
-};
-
-const PREF_FACEDETECTION_ENABLED = "camera.control.face_detection.enabled";
-
-var cameraObj;
-var oldPref;
-
-// Shorthand functions
-function end() {
-  function reallyEnd() {
-    CameraTest.end();
-  }
-  if (oldPref) {
-    SpecialPowers.pushPrefEnv(
-      {'set': [[PREF_FACEDETECTION_ENABLED, oldPref]]}, reallyEnd);
-  } else {
-    SpecialPowers.pushPrefEnv(
-      {'clear': [[PREF_FACEDETECTION_ENABLED]]}, reallyEnd);
-  }
-}
-function next() {
-  CameraTest.next();
-}
-
-function compareFaces(aFaces, expected)
-{
-  ok(aFaces, "have detected faces object");
-  ok(aFaces.length == expected.faces.length,
-    "expected=" + expected.faces.length + ", got=" + aFaces.length);
-  aFaces.forEach(function (face, index) {
-    let result = compareFace(face, expected.faces[index]);
-    ok(result === "ok", "face check: " + result);
-    if (result !== "ok") {
-      return false;
-    }
-  });
-  return true;
-}
-
-function compareFace(aFace, expected)
-{
-  if (aFace.id != expected.id) {
-    return "expected face.id=" + expected.id + ", got=" + aFace.id;
-  }
-  if (aFace.score != expected.score) {
-    return "expected face.score=" + expected.score + ", got=" + aFace.score;
-  }
-  if (!aFace.bounds) {
-    return "face.bounds is missing";
-  }
-  if (aFace.bounds.left != expected.bounds.left ||
-      aFace.bounds.top != expected.bounds.top ||
-      aFace.bounds.right != expected.bounds.right ||
-      aFace.bounds.bottom != expected.bounds.bottom) {
-    return "expected face.bounds=" + expected.bounds.toSource() +
-      ", got=({left:" + aFace.bounds.left + ", top:" + aFace.bounds.top + ", right:" + aFace.bounds.right + ", bottom:" + aFace.bounds.bottom + "})";
-  }
-
-  if (aFace.leftEye && !expected.leftEye) {
-    return "expected null face.leftEye, got=({x:" + aFace.leftEye.x + ", y:" + aFace.leftEye.y + "})";
-  }
-  if (!aFace.leftEye && expected.leftEye) {
-    return "expected face.leftEye=" + expected.leftEye.toSource() + ", got null leftEye";
-  }
-  if (aFace.leftEye && expected.leftEye &&
-      (aFace.leftEye.x != expected.leftEye.x || aFace.leftEye.y != expected.leftEye.y)) {
-    return "expected face.leftEye=" + expected.leftEye.toSource() +
-      ", got=({x:" + aFace.leftEye.x + ", y:" + aFace.leftEye.y + "})";
-  }
-
-  if (aFace.rightEye && !expected.rightEye) {
-    return "expected null face.rightEye, got=({x:" + aFace.rightEye.x + ", y:" + aFace.rightEye.y + "})";
-  }
-  if (!aFace.rightEye && expected.rightEye) {
-    return "expected face.rightEye=" + expected.rightEye.toSource() + ", got null rightEye";
-  }
-  if (aFace.rightEye && expected.rightEye &&
-      (aFace.rightEye.x != expected.rightEye.x || aFace.rightEye.y != expected.rightEye.y)) {
-    return "expected face.rightEye=" + expected.rightEye.toSource() +
-      ", got=({x:" + aFace.rightEye.x + ", y:" + aFace.rightEye.y + "})";
-  }
-
-  if (aFace.mouth && !expected.mouth) {
-    return "expected null face.mouth, got=({x:" + aFace.mouth.x + ", y:" + aFace.mouth.y + "})";
-  }
-  if (!aFace.mouth && expected.mouth) {
-    return "expected face.mouth=" + expected.mouth.toSource() + ", got null mouth";
-  }
-  if (aFace.mouth && expected.mouth &&
-      (aFace.mouth.x != expected.mouth.x || aFace.mouth.y != expected.mouth.y)) {
-    return "expected face.mouth=" + expected.mouth.toSource() +
-      ", got=({x:" + aFace.mouth.x + ", y:" + aFace.mouth.y + "})";
-  }
-
-  return "ok";
-}
-
-var tests = [
-  {
-    key: "face-detection-detected-one-face",
-    func: function testFaceDetectionFoundOneFace(camera) {
-      var expected = {
-        faces: [ {
-          id:       1,
-          score:    2,
-          bounds: {
-            left:   3,
-            top:    4,
-            right:  5,
-            bottom: 6
-          },
-          leftEye: {
-            x:      7,
-            y:      8
-          },
-          rightEye: {
-            x:      9,
-            y:      10
-          },
-          mouth: {
-            x:      11,
-            y:      12
-          }
-        } ]
-      };
-      camera.onFacesDetected = function(aFaces) {
-        ok(compareFaces(aFaces, expected),
-          "onFaceDetected received the detected faces correctly");
-        camera.stopFaceDetection();
-        next();
-      }
-      camera.startFaceDetection();
-    }
-  },
-  {
-    key: "face-detection-detected-two-faces",
-    func: function testFaceDetectionFoundTwoFace(camera) {
-      var expected = {
-        faces: [ {
-          id:       1,
-          score:    2,
-          bounds: {
-            left:   3,
-            top:    4,
-            right:  5,
-            bottom: 6
-          },
-          leftEye: {
-            x:      7,
-            y:      8
-          },
-          rightEye: {
-            x:      9,
-            y:      10
-          },
-          mouth: {
-            x:      11,
-            y:      12
-          }
-        },
-        {
-          id:       13,
-          score:    14,
-          bounds: {
-            left:   15,
-            top:    16,
-            right:  17,
-            bottom: 18
-          },
-          leftEye: {
-            x:      19,
-            y:      20
-          },
-          rightEye: {
-            x:      21,
-            y:      22
-          },
-          mouth: {
-            x:      23,
-            y:      24
-          }
-        } ]
-      };
-      camera.onFacesDetected = function(aFaces) {
-        ok(compareFaces(aFaces, expected),
-          "onFaceDetected received the detected faces correctly");
-        camera.stopFaceDetection();
-        next();
-      }
-      camera.startFaceDetection();
-    }
-  },
-  {
-    key: "face-detection-detected-one-face-no-features",
-    func: function (camera) {
-      var expected = {
-        faces: [ {
-          id:       1,
-          score:    100,
-          bounds: {
-            left:   3,
-            top:    4,
-            right:  5,
-            bottom: 6
-          },
-          leftEye:  null,
-          rightEye: null,
-          mouth:    null
-        } ]
-      };
-      camera.onFacesDetected = function(aFaces) {
-        ok(compareFaces(aFaces, expected),
-          "onFaceDetected received the detected faces correctly");
-        camera.stopFaceDetection();
-        next();
-      }
-      camera.startFaceDetection();
-    }
-  },
-  {
-    key: "face-detection-no-faces-detected",
-    func: function (camera) {
-      var expected = {
-        faces: []
-      };
-      camera.onFacesDetected = function(aFaces) {
-        ok(compareFaces(aFaces, expected),
-          "onFaceDetected received the detected faces correctly");
-        camera.stopFaceDetection();
-        next();
-      }
-      camera.startFaceDetection();
-    }
-  },
-];
-
-var testGenerator = function() {
-  for (var i = 0; i < tests.length; ++i ) {
-    yield tests[i];
-  }
-}();
-
-window.addEventListener('beforeunload', function() {
-  document.getElementById('viewfinder').mozSrcObject = null;
-  if (cameraObj) {
-    cameraObj.release();
-    cameraObj = null;
-  }
-});
-
-// Must call CameraTest.begin() before any other async methods.
-CameraTest.begin("hardware", function(test) {
-  // If the pref doesn't exist, this get will fail; catch it and continue.
-  try {
-    oldPref = SpecialPowers.getBoolPref(PREF_FACEDETECTION_ENABLED);
-  } catch(e) { }
-
-  SpecialPowers.pushPrefEnv({'set': [[PREF_FACEDETECTION_ENABLED, true]]}, function() {
-    var enabled;
-    try {
-      enabled = SpecialPowers.getBoolPref(PREF_FACEDETECTION_ENABLED);
-    } catch(e) { }
-    ok(enabled, PREF_FACEDETECTION_ENABLED + " is " + enabled);
-
-    function onSuccess(camera, config) {
-      document.getElementById('viewfinder').mozSrcObject = camera;
-      cameraObj = camera;
-      CameraTest.next = function() {
-        try {
-          var t = testGenerator.next();
-          test.set(t.key, t.func.bind(undefined, camera));
-        } catch(e) {
-          if (e instanceof StopIteration) {
-            end();
-          } else {
-            throw e;
-          }
-        }
-      };
-      next();
-    }
-    function onError(error) {
-      ok(false, "getCamera() failed with: " + error);
-      end();
-    }
-    navigator.mozCameras.getCamera(whichCamera, initialConfig, onSuccess, onError);
-  })
-});
-
-</script>
-</body>
-
-</html>
deleted file mode 100644
--- a/dom/camera/test/callback/test_camera_hardware_failures.html
+++ /dev/null
@@ -1,145 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-<!--
-https://bugzilla.mozilla.org/show_bug.cgi?id=940424
--->
-<head>
-  <title>Bug 940424 - Test camera hardware API failure handling</title>
-  <script type="text/javascript" src="/MochiKit/MochiKit.js"></script>
-  <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
-  <script type="text/javascript" src="../camera_common.js"></script>
-  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
-</head>
-<body>
-  <a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=940424">Mozilla Bug 940424</a>
-  <video id="viewfinder" width = "200" height = "200" autoplay></video>
-  <img src="#" alt="This image is going to load" id="testimage"/>
-
-<script class="testbody" type="text/javascript;version=1.7">
-
-var whichCamera = navigator.mozCameras.getListOfCameras()[0];
-var initialConfig = {
-  mode: 'picture',
-  recorderProfile: 'cif',
-  previewSize: {
-    width: 352,
-    height: 288
-  }
-};
-
-var cameraObj;
-
-// Shorthand functions
-function end() {
-  CameraTest.end();
-}
-function next() {
-  CameraTest.next();
-}
-
-// The array of tests
-var tests = [
-  {
-    key: "auto-focus-failure",
-    func: function testAutoFocusApiFailure(camera) {
-      function onSuccess(success) {
-        ok(false, "autoFocus() succeeded incorrectly");
-        end();
-      }
-      function onError(error) {
-        ok(true, "autoFocus() failed correctly with: " + error);
-        next();
-      }
-      camera.autoFocus(onSuccess, onError);
-    }
-  },
-  {
-    key: "auto-focus-process-failure",
-    func: function testAutoFocusProcessFailure(camera) {
-      function onSuccess(success) {
-        if (success) {
-          ok(false, "autoFocus() process succeeded incorrectly");
-          end();
-        } else {
-          ok(true, "autoFocus() process failed correctly");
-          next();
-        }
-      }
-      function onError(error) {
-        ok(false, "autoFocus() process failed incorrectly with: " + error);
-        end();
-      }
-      camera.autoFocus(onSuccess, onError);
-    }
-  },
-  {
-    key: "take-picture-failure",
-    func: function testTakePictureApiFailure(camera) {
-      function onSuccess(picture) {
-        ok(false, "takePicture() succeeded incorrectly");
-        end();
-      }
-      function onError(error) {
-        ok(true, "takePicture() failed correctly with: " + error);
-        next();
-      }
-      camera.takePicture(null, onSuccess, onError);
-    }
-  },
-  {
-    key: "take-picture-process-failure",
-    func: function testTakePictureProcessFailure(camera) {
-      function onSuccess(picture) {
-        ok(false, "takePicture() process succeeded incorrectly");
-        end();
-      }
-      function onError(error) {
-        ok(true, "takePicture() process failed correctly with: " + error);
-        next();
-      }
-      camera.takePicture(null, onSuccess, onError);
-    }
-  },
-];
-
-var testGenerator = function() {
-  for (var i = 0; i < tests.length; ++i ) {
-    yield tests[i];
-  }
-}();
-
-window.addEventListener('beforeunload', function() {
-  document.getElementById('viewfinder').mozSrcObject = null;
-  cameraObj.release();
-  cameraObj = null;
-});
-
-CameraTest.begin("hardware", function(test) {
-  function onSuccess(camera, config) {
-    document.getElementById('viewfinder').mozSrcObject = camera;
-    cameraObj = camera;
-    CameraTest.next = function() {
-      try {
-        var t = testGenerator.next();
-        test.set(t.key, t.func.bind(undefined, camera));
-      } catch(e) {
-        if (e instanceof StopIteration) {
-          end();
-        } else {
-          throw e;
-        }
-      }
-    };
-    next();
-  }
-  function onError(error) {
-    ok(false, "getCamera() failed with: " + error);
-    end();
-  }
-  navigator.mozCameras.getCamera(whichCamera, initialConfig, onSuccess, onError);
-});
-
-</script>
-</body>
-
-</html>
deleted file mode 100644
--- a/dom/camera/test/callback/test_camera_hardware_init_failure.html
+++ /dev/null
@@ -1,149 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-<!--
-https://bugzilla.mozilla.org/show_bug.cgi?id=940424
--->
-<head>
-  <title>Bug 940424 - Test camera hardware init failure handling</title>
-  <script type="text/javascript" src="/MochiKit/MochiKit.js"></script>
-  <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
-  <script type="text/javascript" src="../camera_common.js"></script>
-  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
-</head>
-<body>
-  <a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=940424">Mozilla Bug 940424</a>
-  <video id="viewfinder" width="200" height="200" autoplay></video>
-  <img src="#" alt="This image is going to load" id="testimage"/>
-
-<script class="testbody" type="text/javascript;version=1.7">
-
-SimpleTest.waitForExplicitFinish();
-
-var whichCamera = navigator.mozCameras.getListOfCameras()[0];
-var initialConfig = {
-  mode: 'picture',
-  recorderProfile: 'cif',
-  previewSize: {
-    width: 352,
-    height: 288
-  }
-};
-
-var tests = [
-  {
-    name: "init-failure",
-    key: "init-failure",
-    func: function testInitFailure(test) {
-      function onSuccess(camera, config) {
-        ok(false, "onSuccess called incorrectly");
-        camera.release();
-        test.next();
-      }
-      function onError(error) {
-        ok(true, "onError called correctly on init failure");
-        test.next();
-      }
-      info("Running test: init-failure");
-      navigator.mozCameras.getCamera(whichCamera, initialConfig, onSuccess, onError);
-    }
-  },
-  /* This test case (init-success) *must* follow the preceeding test case
-     (init-failure) in order for the desired condition to be verified */
-  {
-    name: "init-success",
-    key: "",
-    func: function(test) {
-      function onSuccess(camera, config) {
-        ok(true, "onSuccess called correctly");
-        camera.release();
-        test.next();
-      }
-      function onError(error) {
-        ok(false, "onError called incorrectly: " + error);
-        test.next();
-      }
-      info("Running test: init-success");
-      navigator.mozCameras.getCamera(whichCamera, initialConfig, onSuccess, onError)
-    }
-  },
-  /* Test for bug 1099390 to make sure events related to the underlying
-     platform failing are generated and handled properly. */
-  {
-    name: "post-init-system-failure",
-    key: "post-init-system-failure",
-    func: function(test) {
-      var gotReleaseCallback = false;
-      var gotCloseCallback = false;
-
-      function gotAll() {
-        var all = gotReleaseCallback && gotCloseCallback;
-        if (all) {
-          info("Got all expected notifications");
-        }
-        return all;
-      }
-
-      function onSuccess(camera, config) {
-        camera.onClosed = function(reason) {
-          camera.onClosed = null;
-          ok(reason === "SystemFailure", "reason is: " + reason);
-          ok(!gotCloseCallback, "gotCloseCallback was " + gotCloseCallback);
-          gotCloseCallback = true;
-          if (gotAll()) {
-            test.next();
-          }
-
-          camera.release(
-            function success() {
-              ok(true, "Got release() success callback");
-              ok(!gotReleaseCallback, "gotReleaseCallback was " + gotReleaseCallback);
-              gotReleaseCallback = true;
-              if (gotAll()) {
-                test.next();
-              }
-            },
-            function error(e) {
-              ok(false, "Unexpected release() onError callback: " + e);
-              test.next();
-            }
-          ); // release()
-        } // onClosed
-      } // onSuccess
-
-      function onError(error) {
-        ok(false, "onError called incorrectly: " + error);
-        test.next();
-      }
-
-      info("Running test: post-init-system-failure");
-      navigator.mozCameras.getCamera(whichCamera, initialConfig, onSuccess, onError);
-    }
-  },
-];
-
-var testGenerator = function() {
-  for (var i = 0; i < tests.length; ++i) {
-    yield tests[i];
-  }
-}();
-
-CameraTest.begin("hardware", function(test) {
-  CameraTest.next = function() {
-    try {
-      var t = testGenerator.next();
-      test.set(t.key, t.func.bind(undefined, CameraTest));
-    } catch(e) {
-      if (e instanceof StopIteration) {
-        CameraTest.end();
-      } else {
-        throw e;
-      }
-    }
-  };
-  CameraTest.next();
-});
-
-</script>
-</body>
-
-</html>
--- a/dom/camera/test/mochitest.ini
+++ b/dom/camera/test/mochitest.ini
@@ -1,21 +1,11 @@
 [DEFAULT]
 support-files = camera_common.js
 
-[callback/test_camera.html]
-[callback/test_camera_2.html]
-[callback/test_camera_3.html]
-[callback/test_camera_hardware_init_failure.html]
-[callback/test_camera_hardware_failures.html]
-[callback/test_bug975472.html]
-[callback/test_camera_hardware_face_detection.html]
-[callback/test_camera_hardware_auto_focus_moving_cb.html]
-[callback/test_bug1022766.html]
-[callback/test_bug1099390.html]
 [test_camera.html]
 [test_camera_2.html]
 [test_camera_3.html]
 [test_camera_hardware_init_failure.html]
 [test_camera_hardware_failures.html]
 [test_bug975472.html]
 [test_camera_fake_parameters.html]
 [test_camera_hardware_face_detection.html]
--- a/dom/camera/test/test_bug1022766.html
+++ b/dom/camera/test/test_bug1022766.html
@@ -33,54 +33,55 @@ var Camera = {
     return document.getElementById('viewfinder');
   },
 
   firstCallFailed: false,
   secondCallSucceeded: false,
   callbackTriggered: false,
   checkForDone: function test_checkForDone() {
     if (Camera.firstCallFailed && Camera.secondCallSucceeded) {
-      ok(Camera.callbackTriggered, "Async callback triggered");
+      ok(Camera.callbackTriggered, "Async callback triggered?");
       Camera.cameraObj.release();
       Camera.cameraObj = null;
       CameraTest.end();
     }
   },
 
   successOne: function test_successOne(focused) {
     ok(false, "First call to autoFocus() succeeded unexpectedly");
   },
   failureOne: function test_failureOne(error) {
     ok(error.name == "NS_ERROR_IN_PROGRESS", "First call to autoFocus() failed with: "
-      + error);
+      + error.name);
     Camera.firstCallFailed = true;
     Camera.checkForDone();
   },
   successTwo: function test_successTwo(focused) {
     ok(true, "Second call to autoFocus() succeeded");
     Camera.secondCallSucceeded = true;
     Camera.checkForDone();
   },
   failureTwo: function test_failureTwo(error) {
     ok(false, "Second call to autoFocus() failed unexpectedly with: " + error);
   },
-  callback: function test_callback(focused) {
+  callback: function test_callback(e) {
+    Camera.cameraObj.removeEventListener('focus', Camera.callback);
     Camera.callbackTriggered = true;
   },
 
   start: function test_start() {
     function onSuccess(d) {
       var camera = d.camera;
       Camera.cameraObj = camera;
       Camera.viewfinder.mozSrcObject = camera;
       Camera.viewfinder.play();
 
       // It doesn't matter if the emulator supports focus or not;
       // this is just testing the sequencing.
-      camera.onAutoFocusCompleted = Camera.callback;
+      camera.addEventListener('focus', Camera.callback);
       camera.autoFocus().then(Camera.successOne, Camera.failureOne);
       camera.autoFocus().then(Camera.successTwo, Camera.failureTwo);
     };
 
     navigator.mozCameras.getCamera(whichCamera, config).then(onSuccess, onError);
   }
 }
 
--- a/dom/camera/test/test_camera.html
+++ b/dom/camera/test/test_camera.html
@@ -98,17 +98,17 @@ var Camera = {
   getPreviewSizes: function camera_preview() {
     this._previewSizes = this.cameraObj.capabilities.previewSizes;
   },
   getZoomRatios: function camera_preview() {
     this._zoomRatios = this.cameraObj.capabilities.zoomRatios;
   },
   takePictureSuccess: function taken_foto(blob) {
     ok(blob.size > 100 , "Blob Size Gathered = " + blob.size);
-    ok("image/" + test.fileFormat ==  blob.type, "Blob Type = " + blob.type);
+    ok("image/" + this._currentTest.fileFormat === blob.type, "Blob Type = " + blob.type);
   },
   takePictureEvent: function taken_foto_evt(e) {
     var blob = e.data;
     var img = new Image();
     var test = this._currentTest;
     var onPreviewStateChange = function(e) {
       if (e.newState === 'started') {
         ok(true, "viewfinder is ready and playing after resume");
--- a/dom/camera/test/test_camera_fake_parameters.html
+++ b/dom/camera/test/test_camera_fake_parameters.html
@@ -31,17 +31,17 @@ function onError(e) {
   ok(false, "Error " + e);
 }
 
 function end() {
   CameraTest.end();
 }
 function next() {
   if (cameraObj) {
-    cameraObj.release(
+    cameraObj.release().then(
       function success() {
         CameraTest.next();
       },
       onError
     );
     cameraObj = null;
   } else {
     CameraTest.next();
@@ -340,17 +340,17 @@ var tests = [
     key: "bug-1054803",
     prep: function setupFakePictureSizes(test) {
       // The important part of this test is that 3264 * 1836 = 5,992,704 = 2448 * 2448,
       // so we need to make sure that the size-matching algorithm picks the right size.
       test.setFakeParameters("picture-size-values=3264x1836,2448x2448,1836x3264", function () {
         run();
       });
     },
-    test: function testFakeFocusAreas(cam, cap) {
+    test: function testFakePictureSizes(cam, cap) {
       // validate the capability attribute
       ok(cap.pictureSizes.length == 3, "pictureSizes.length = " + cap.pictureSizes.length);
       var found = 0;
       [ { height: 3264, width: 1836 },
         { height: 1836, width: 3264 },
         { height: 2448, width: 2448 } ].forEach(function(size) {
         found = 0;
         cap.pictureSizes.forEach(function(capSize) {
@@ -363,17 +363,17 @@ var tests = [
 
       // test setters and getters
       var sync = new Promise(function(resolve, reject) {
         // Use setConfiguration() (which will fail on the profile)
         // to signify that the CameraControl thread has run and our
         // settings are applied. Yes--this is an ugly hack.
         cam.setConfiguration({ mode: 'video',
                                recorderProfile: 'weird-unsupported-profile'
-                             }, resolve, resolve);
+                             }).then(resolve, resolve);
       });
       var sizeGenerator = function() {
         var sizes = [ { height: 3264, width: 1836 },
                       { height: 1836, width: 3264 },
                       { height: 2448, width: 2448 } ];
         for (var i = 0; i < sizes.length; ++i) {
           yield sizes[i];
         }
--- a/dom/webidl/CameraControl.webidl
+++ b/dom/webidl/CameraControl.webidl
@@ -106,27 +106,16 @@ dictionary CameraStartRecordingOptions
      will be automatically changed to "torch" until stopRecording() is
      called. During this time, flashMode will reflect the new setting. If
      flashMode is changed while recording is in progress, the new setting
      will be left as-is on stopRecording(). If the camera does not
      support this setting, it will be ignored. */
   boolean autoEnableLowLightTorch = false;
 };
 
-callback CameraSetConfigurationCallback = void (CameraConfiguration configuration);
-callback CameraAutoFocusCallback = void (boolean focused);
-callback CameraTakePictureCallback = void (Blob picture);
-callback CameraStartRecordingCallback = void ();
-callback CameraShutterCallback = void ();
-callback CameraClosedCallback = void (DOMString reason);
-callback CameraReleaseCallback = void ();
-callback CameraRecorderStateChange = void (DOMString newState);
-callback CameraPreviewStateChange = void (DOMString newState);
-callback CameraAutoFocusMovingCallback = void (boolean isMoving);
-
 /*
     attributes here affect the preview, any pictures taken, and/or
     any video recorded by the camera.
 */
 [Func="nsDOMCameraControl::HasSupport"]
 interface CameraControl : MediaStream
 {
   [Constant, Cached]
@@ -226,72 +215,48 @@ interface CameraControl : MediaStream
   [Throws]
   attribute double          exposureCompensation;
 
   /* one of the values chosen from capabilities.isoModes; default
      value is "auto" if supported. */
   [Throws]
   attribute DOMString       isoMode;
 
-  /* the function to call on the camera's shutter event, to trigger
-     a shutter sound and/or a visual shutter indicator. */
-  attribute CameraShutterCallback? onShutter;
-
   /* the event dispatched on the camera's shutter event, to trigger
      a shutter sound and/or a visual shutter indicator.
 
      contains no event-specific data. */
-  attribute EventHandler onshutter;
-
-  /* the function to call when the camera hardware is closed; this may
-     be due to a system failure, another process taking over the camera,
-     or a call to release().
-
-     The 'reason' will be one of the following string values:
-       - SystemFailure    : the camera subsystem failed and was closed;
-       - HardwareReleased : a call to release() was successful;
-       - NotAvailable     : the camera hardware is in use by another process.
-  */
-  attribute CameraClosedCallback? onClosed;
+  attribute EventHandler    onshutter;
 
   /* the event dispatched when the camera hardware is closed; this may
      be due to a system failure, another process taking over the camera,
      or a call to release().
 
      The event has a 'reason' attribute that will be one of the following
      string values:
        - SystemFailure    : the camera subsystem failed and was closed;
        - HardwareReleased : a call to release() was successful;
        - NotAvailable     : the camera hardware is in use by another process.
   */
-  attribute EventHandler onclose;
-
-  /* the function to call when the recorder changes state, either because
-     the recording process encountered an error, or because one of the
-     recording limits (see CameraStartRecordingOptions) was reached. */
-  attribute CameraRecorderStateChange? onRecorderStateChange;
+  attribute EventHandler    onclose;
 
   /* the event dispatched when the recorder changes state, either because
      the recording process encountered an error, or because one of the
      recording limits (see CameraStartRecordingOptions) was reached.
 
      event type is CameraStateChangeEvent where:
          'newState' is the new recorder state */
-  attribute EventHandler onrecorderstatechange;
-
-  /* the function to call when the viewfinder stops or starts,
-     useful for synchronizing other UI elements. */
-  attribute CameraPreviewStateChange? onPreviewStateChange;
+  attribute EventHandler    onrecorderstatechange;
 
   /* the event dispatched when the viewfinder stops or starts,
      useful for synchronizing other UI elements.
 
      event type is CameraStateChangeEvent where:
          'newState' is the new preview state */
-  attribute EventHandler onpreviewstatechange;
+  attribute EventHandler    onpreviewstatechange;
 
   /* the size of the picture to be returned by a call to takePicture();
      an object with 'height' and 'width' properties that corresponds to
      one of the options returned by capabilities.pictureSizes. */
   [Throws]
   CameraSize getPictureSize();
   [Throws]
   void setPictureSize(optional CameraSize size);
@@ -299,17 +264,17 @@ interface CameraControl : MediaStream
   /* if the image blob to be returned by takePicture() supports lossy
      compression, this setting controls the quality-size trade-off;
      valid values range from 0.0 for smallest size/worst quality to 1.0
      for largest size/best quality. Note that depending on the range of
      values supported by the underlying platform, this attribute may not
      'get' the exact value that was previously 'set'. If this setting is
      not supported, it is ignored. */
   [Throws]
-  attribute double           pictureQuality;
+  attribute double          pictureQuality;
 
   /* the size of the thumbnail to be included in the picture returned
      by a call to takePicture(), assuming the chosen fileFormat supports
      one; an object with 'height' and 'width' properties that corresponds
      to one of the options returned by capabilities.pictureSizes.
 
      this setting should be considered a hint: the implementation will
      respect it when possible, and override it if necessary. */
@@ -321,108 +286,77 @@ interface CameraControl : MediaStream
   /* the angle, in degrees, that the image sensor is mounted relative
      to the display; e.g. if 'sensorAngle' is 270 degrees (or -90 degrees),
      then the preview stream needs to be rotated +90 degrees to have the
      same orientation as the real world. */
   readonly attribute long   sensorAngle;
 
   /* tell the camera to attempt to focus the image */
   [Throws]
-  Promise<boolean> autoFocus(optional CameraAutoFocusCallback onSuccess,
-                             optional CameraErrorCallback onError);
+  Promise<boolean> autoFocus();
 
   /* the event dispatched whenever the focus state changes due to calling
      autoFocus or due to continuous autofocus.
 
      if continuous autofocus is supported and focusMode is set to enable it,
      then this event is dispatched whenever the camera decides to start and
      stop moving the focus position; it can be used to update a UI element to
      indicate that the camera is still trying to focus, or has finished. Some
      platforms do not support this event, in which case the callback is never
      invoked.
 
      event type is CameraStateChangeEvent where:
          'newState' is one of the following states:
              'focused' if the focus is now set
              'focusing' if the focus is moving
              'unfocused' if last attempt to focus failed */
-  attribute EventHandler onfocus;
-
-  /* if continuous autofocus is supported and focusMode is set to enable it,
-     then this function is called whenever the camera decides to start and
-     stop moving the focus position; it can be used to update a UI element to
-     indicate that the camera is still trying to focus, or has finished. Some
-     platforms do not support this event, in which case the callback is never
-     invoked. */
-  [Pref="camera.control.autofocus_moving_callback.enabled"]
-  attribute CameraAutoFocusMovingCallback? onAutoFocusMoving;
-
-  /* this function is called whenever auto focus completes, due to continuous
-     autofocus or a solicited auto focus.  */
-  attribute CameraAutoFocusCallback? onAutoFocusCompleted;
+  attribute EventHandler    onfocus;
 
   /* capture an image and return it as a blob to the 'onSuccess' callback;
      if the camera supports it, this may be invoked while the camera is
      already recording video.
 
      invoking this function will stop the preview stream, which must be
-     manually restarted (e.g. by calling .play() on it). */
+     manually restarted by calling resumePreview(). */
   [Throws]
-  Promise<Blob> takePicture(optional CameraPictureOptions aOptions,
-                            optional CameraTakePictureCallback onSuccess,
-                            optional CameraErrorCallback onError);
+  Promise<Blob> takePicture(optional CameraPictureOptions options);
 
   /* the event dispatched when a picture is successfully taken; it is of the
      type BlobEvent, where the data attribute contains the picture. */
-  attribute EventHandler onpicture;
+  attribute EventHandler    onpicture;
 
-  /* start recording video; 'aOptions' is a CameraStartRecordingOptions object.
+  /* start recording video; 'options' is a CameraStartRecordingOptions object.
      If the success/error callbacks are not used, one may determine success by
      waiting for the recorderstatechange event. */
   [Throws]
-  Promise<void> startRecording(CameraStartRecordingOptions aOptions,
+  Promise<void> startRecording(CameraStartRecordingOptions options,
                                DeviceStorage storageArea,
-                               DOMString filename,
-                               optional CameraStartRecordingCallback onSuccess,
-                               optional CameraErrorCallback onError);
+                               DOMString filename);
 
   /* stop precording video. */
   [Throws]
   void stopRecording();
 
   /* call in or after the takePicture() onSuccess callback to
      resume the camera preview stream. */
   [Throws]
   void resumePreview();
 
   /* release the camera so that other applications can use it; you should
      probably call this whenever the camera is not longer in the foreground
      (depending on your usage model).
 
-     the callbacks are optional, unless you really need to know when
-     the hardware is ultimately released.
-
      once this is called, the camera control object is to be considered
      defunct; a new instance will need to be created to access the camera. */
   [Throws]
-  Promise<void> release(optional CameraReleaseCallback onSuccess,
-                        optional CameraErrorCallback onError);
-
-  /* changes the camera configuration on the fly;
-     'configuration' is of type CameraConfiguration.
+  Promise<void> release();
 
-     XXXmikeh the 'configuration' argument needs to be optional, else
-     the WebIDL compiler throws: "WebIDL.WebIDLError: error: Dictionary
-     argument or union argument containing a dictionary not followed by
-     a required argument must be optional"
-  */
+  /* changes the camera configuration on the fly. */
   [Throws]
-  Promise<CameraConfiguration> setConfiguration(optional CameraConfiguration configuration,
-                                                optional CameraSetConfigurationCallback onSuccess,
-                                                optional CameraErrorCallback onError);
+  Promise<CameraConfiguration> setConfiguration(optional CameraConfiguration configuration);
 
   /* the event dispatched when the camera is successfully configured.
 
      event type is CameraConfigurationEvent where:
          'mode' is the selected camera mode
          'recorderProfile' is the selected profile
          'width' contains the preview width
          'height' contains the preview height */
@@ -519,17 +453,12 @@ partial interface CameraControl
 
   /* Stops the face detection.
 
      This method throws an exception if face detection can't be stopped.
   */
   [Throws, Pref="camera.control.face_detection.enabled"]
   void stopFaceDetection();
 
-  /* Callback for faces detected in the preview frame. If no faces are
-     detected, the callback is invoked with an empty sequence. */
-  [Pref="camera.control.face_detection.enabled"]
-  attribute CameraFaceDetectionCallback? onFacesDetected;
-
   /* CameraFacesDetectedEvent */
   [Pref="camera.control.face_detection.enabled"]
-  attribute EventHandler onfacesdetected;
+  attribute EventHandler    onfacesdetected;
 };
--- a/dom/webidl/CameraManager.webidl
+++ b/dom/webidl/CameraManager.webidl
@@ -19,31 +19,24 @@ dictionary CameraSize
 dictionary CameraConfiguration
 {
   CameraMode mode = "unspecified";
   CameraSize previewSize = null;
   DOMString recorderProfile = ""; // one of the profiles reported by
                                   // CameraControl.capabilities.recorderProfiles
 };
 
-callback CameraErrorCallback = void (DOMString error);
-
-callback GetCameraCallback = void (CameraControl camera,
-                                   CameraConfiguration configuration);
-
 [Func="nsDOMCameraManager::HasSupport"]
 interface CameraManager
 {
   /* get a camera instance; 'camera' is one of the camera
      identifiers returned by getListOfCameras() below.
   */
   [Throws]
   Promise<CameraGetPromiseData> getCamera(DOMString camera,
-                                          optional CameraConfiguration initialConfiguration,
-                                          optional GetCameraCallback callback,
-                                          optional CameraErrorCallback errorCallback);
+                                          optional CameraConfiguration initialConfiguration);
 
   /* return an array of camera identifiers, e.g.
        [ "front", "back" ]
    */
   [Throws]
   sequence<DOMString> getListOfCameras();
 };
deleted file mode 100644
--- a/gfx/layers/apz/src/InputBlockState.h.orig
+++ /dev/null
@@ -1,247 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim: set sw=2 ts=8 et tw=80 : */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#ifndef mozilla_layers_InputBlockState_h
-#define mozilla_layers_InputBlockState_h
-
-#include "nsTArray.h"                       // for nsTArray
-#include "InputData.h"                      // for MultiTouchInput
-#include "nsAutoPtr.h"
-
-namespace mozilla {
-namespace layers {
-
-class AsyncPanZoomController;
-class OverscrollHandoffChain;
-class CancelableBlockState;
-class TouchBlockState;
-class WheelBlockState;
-
-/**
- * A base class that stores state common to various input blocks.
- * Currently, it just stores the overscroll handoff chain.
- */
-class InputBlockState
-{
-public:
-  static const uint64_t NO_BLOCK_ID = 0;
-
-  explicit InputBlockState(const nsRefPtr<AsyncPanZoomController>& aTargetApzc,
-                           bool aTargetConfirmed);
-  virtual ~InputBlockState()
-  {}
-
-  bool SetConfirmedTargetApzc(const nsRefPtr<AsyncPanZoomController>& aTargetApzc);
-  const nsRefPtr<AsyncPanZoomController>& GetTargetApzc() const;
-  const nsRefPtr<const OverscrollHandoffChain>& GetOverscrollHandoffChain() const;
-  uint64_t GetBlockId() const;
-
-  bool IsTargetConfirmed() const;
-
-private:
-  nsRefPtr<AsyncPanZoomController> mTargetApzc;
-  nsRefPtr<const OverscrollHandoffChain> mOverscrollHandoffChain;
-  bool mTargetConfirmed;
-  const uint64_t mBlockId;
-};
-
-/**
- * This class represents a set of events that can be cancelled by web content
- * via event listeners.
- *
- * Each cancelable input block can be cancelled by web content, and
- * this information is stored in the mPreventDefault flag. Because web
- * content runs on the Gecko main thread, we cannot always wait for web content's
- * response. Instead, there is a timeout that sets this flag in the case
- * where web content doesn't respond in time. The mContentResponded
- * and mContentResponseTimerExpired flags indicate which of these scenarios
- * occurred.
- */
-class CancelableBlockState : public InputBlockState
-{
-public:
-  CancelableBlockState(const nsRefPtr<AsyncPanZoomController>& aTargetApzc,
-                       bool aTargetConfirmed);
-
-  virtual TouchBlockState *AsTouchBlock() {
-    return nullptr;
-  }
-
-  /**
-   * Record whether or not content cancelled this block of events.
-   * @param aPreventDefault true iff the block is cancelled.
-   * @return false if this block has already received a response from
-   *         web content, true if not.
-   */
-  bool SetContentResponse(bool aPreventDefault);
-
-  /**
-   * Record that content didn't respond in time.
-   * @return false if this block already timed out, true if not.
-   */
-  bool TimeoutContentResponse();
-
-  /**
-   * @return true iff web content cancelled this block of events.
-   */
-  bool IsDefaultPrevented() const;
-
-  /**
-   * @return true iff this block has received all the information needed
-   *         to properly dispatch the events in the block.
-   */
-  virtual bool IsReadyForHandling() const;
-
-<<<<<<< HEAD
-private:
-=======
-  /**
-   * Returns whether or not this block has pending events.
-   */
-  virtual bool HasEvents() const = 0;
-
-  /**
-   * Throw away all the events in this input block.
-   */
-  virtual void DropEvents() = 0;
-
-  /**
-   * Process all events given an apzc, leaving ths block depleted.
-   */
-  virtual void HandleEvents(const nsRefPtr<AsyncPanZoomController>& aTarget) = 0;
-
-  /**
-   * Return true if this input block must stay active if it would otherwise
-   * be removed as the last item in the pending queue.
-   */
-  virtual bool MustStayActive() = 0;
-
-  /**
-   * Return a descriptive name for the block kind.
-   */
-  virtual const char* Type() = 0;
-
- private:
->>>>>>> 80325be... Refactor InputQueue to hold more than touch events. (bug 1013432 part 2, r=kats)
-  bool mPreventDefault;
-  bool mContentResponded;
-  bool mContentResponseTimerExpired;
-};
-
-/**
- * This class represents a single touch block. A touch block is
- * a set of touch events that can be cancelled by web content via
- * touch event listeners.
- *
- * Every touch-start event creates a new touch block. In this case, the
- * touch block consists of the touch-start, followed by all touch events
- * up to but not including the next touch-start (except in the case where
- * a long-tap happens, see below). Note that in particular we cannot know
- * when a touch block ends until the next one is started. Most touch
- * blocks are created by receipt of a touch-start event.
- *
- * Every long-tap event also creates a new touch block, since it can also
- * be consumed by web content. In this case, when the long-tap event is
- * dispatched to web content, a new touch block is started to hold the remaining
- * touch events, up to but not including the next touch start (or long-tap).
- *
- * Additionally, if touch-action is enabled, each touch block should
- * have a set of allowed touch behavior flags; one for each touch point.
- * This also requires running code on the Gecko main thread, and so may
- * be populated with some latency. The mAllowedTouchBehaviorSet and
- * mAllowedTouchBehaviors variables track this information.
- */
-class TouchBlockState : public CancelableBlockState
-{
-public:
-  typedef uint32_t TouchBehaviorFlags;
-
-  explicit TouchBlockState(const nsRefPtr<AsyncPanZoomController>& aTargetApzc,
-                           bool aTargetConfirmed);
-
-  TouchBlockState *AsTouchBlock() MOZ_OVERRIDE {
-    return this;
-  }
-
-  /**
-   * Set the allowed touch behavior flags for this block.
-   * @return false if this block already has these flags set, true if not.
-   */
-  bool SetAllowedTouchBehaviors(const nsTArray<TouchBehaviorFlags>& aBehaviors);
-  /**
-   * Copy the allowed touch behavior flags from another block.
-   * @return false if this block already has these flags set, true if not.
-   */
-  bool CopyAllowedTouchBehaviorsFrom(const TouchBlockState& aOther);
-
-  /**
-   * @return true iff this block has received all the information needed
-   *         to properly dispatch the events in the block.
-   */
-  bool IsReadyForHandling() const MOZ_OVERRIDE;
-
-  /**
-   * Set a flag that disables setting the single-tap flag on this block.
-   */
-  void DisallowSingleTap();
-  /**
-   * Set a flag that indicates that this touch block triggered a single tap event.
-   * @return true iff DisallowSingleTap was not previously called.
-   */
-  bool SetSingleTapOccurred();
-  /**
-   * @return true iff SetSingleTapOccurred was previously called on this block.
-   */
-  bool SingleTapOccurred() const;
-
-  /**
-   * Add a new touch event to the queue of events in this input block.
-   */
-  void AddEvent(const MultiTouchInput& aEvent);
-
-  /**
-   * @return false iff touch-action is enabled and the allowed touch behaviors for
-   *         this touch block do not allow pinch-zooming.
-   */
-  bool TouchActionAllowsPinchZoom() const;
-  /**
-   * @return false iff touch-action is enabled and the allowed touch behaviors for
-   *         this touch block do not allow double-tap zooming.
-   */
-  bool TouchActionAllowsDoubleTapZoom() const;
-  /**
-   * @return false iff touch-action is enabled and the allowed touch behaviors for
-   *         the first touch point do not allow panning in the specified direction(s).
-   */
-  bool TouchActionAllowsPanningX() const;
-  bool TouchActionAllowsPanningY() const;
-  bool TouchActionAllowsPanningXY() const;
-
-  bool HasEvents() const MOZ_OVERRIDE;
-  void DropEvents() MOZ_OVERRIDE;
-  void HandleEvents(const nsRefPtr<AsyncPanZoomController>& aTarget) MOZ_OVERRIDE;
-  bool MustStayActive() MOZ_OVERRIDE;
-  const char* Type() MOZ_OVERRIDE;
-
-private:
-  /**
-   * @return the first event in the queue. The event is removed from the queue
-   *         before it is returned.
-   */
-  MultiTouchInput RemoveFirstEvent();
-
-private:
-  nsTArray<TouchBehaviorFlags> mAllowedTouchBehaviors;
-  bool mAllowedTouchBehaviorSet;
-  bool mSingleTapDisallowed;
-  bool mSingleTapOccurred;
-  nsTArray<MultiTouchInput> mEvents;
-};
-
-} // namespace layers
-} // namespace mozilla
-
-#endif // mozilla_layers_InputBlockState_h
--- a/modules/libpref/init/all.js
+++ b/modules/libpref/init/all.js
@@ -4383,17 +4383,16 @@ pref("image.mozsamplesize.enabled", fals
 
 // Enable navigator.sendBeacon on all platforms except b2g because it doesn't
 // play nicely with Firefox OS apps yet.
 #ifndef MOZ_WIDGET_GONK
 pref("beacon.enabled", true);
 #endif
 
 // Camera prefs
-pref("camera.control.autofocus_moving_callback.enabled", true);
 pref("camera.control.face_detection.enabled", true);
 
 // Fetch API.
 pref("dom.fetch.enabled", false);
 #ifdef MOZ_WIDGET_GONK
 // Empirically, this is the value returned by hal::GetTotalSystemMemory()
 // when Flame's memory is limited to 512MiB. If the camera stack determines
 // it is running on a low memory platform, features that can be reliably