dom/camera/CameraControlImpl.cpp

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   3  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #include "CameraControlImpl.h"
   6 #include "base/basictypes.h"
   7 #include "mozilla/Assertions.h"
   8 #include "mozilla/unused.h"
   9 #include "nsPrintfCString.h"
  10 #include "nsIWeakReferenceUtils.h"
  11 #include "CameraRecorderProfiles.h"
  12 #include "CameraCommon.h"
  13 #include "nsGlobalWindow.h"
  14 #include "DeviceStorageFileDescriptor.h"
  15 #include "CameraControlListener.h"
  16
  17 using namespace mozilla;
  18
  19 /* static */ StaticRefPtr<nsIThread> CameraControlImpl::sCameraThread;
  20
  21 CameraControlImpl::CameraControlImpl()
  22   : mListenerLock(PR_NewRWLock(PR_RWLOCK_RANK_NONE, "CameraControlImpl.Listeners.Lock"))
  23   , mPreviewState(CameraControlListener::kPreviewStopped)
  24   , mHardwareState(CameraControlListener::kHardwareClosed)
  25 {
  26   DOM_CAMERA_LOGT("%s:%d : this=%p\n", __func__, __LINE__, this);
  27
  28   // reuse the same camera thread to conserve resources
  29   nsCOMPtr<nsIThread> ct = do_QueryInterface(sCameraThread);
  30   if (ct) {
  31     mCameraThread = ct.forget();
  32   } else {
  33     nsresult rv = NS_NewNamedThread("CameraThread", getter_AddRefs(mCameraThread));
  34     if (NS_FAILED(rv)) {
  35       MOZ_CRASH("Failed to create new Camera Thread");
  36     }
  37
  38     // keep a weak reference to the new thread
  39     sCameraThread = mCameraThread;
  40   }
  41
  42   // Care must be taken with the mListenerLock read-write lock to prevent
  43   // deadlocks. Currently this is handled by ensuring that any attempts to
  44   // acquire the lock for writing (as in Add/RemoveListener()) happen in a
  45   // runnable dispatched to the Camera Thread--even if the method is being
  46   // called from that thread. This ensures that if a registered listener
  47   // (which is invoked with a read-lock) tries to call Add/RemoveListener(),
  48   // the lock-for-writing attempt won't happen until the listener has
  49   // completed.
  50   //
  51   // Multiple parallel listeners being invoked are not a problem because
  52   // the read-write lock allows multiple simultaneous read-locks.
  53   if (!mListenerLock) {
  54     MOZ_CRASH("Out of memory getting new PRRWLock");
  55   }
  56 }
  57
  58 CameraControlImpl::~CameraControlImpl()
  59 {
  60   DOM_CAMERA_LOGT("%s:%d : this=%p\n", __func__, __LINE__, this);
  61
  62   MOZ_ASSERT(mListenerLock, "mListenerLock missing in ~CameraControlImpl()");
  63   if (mListenerLock) {
  64     PR_DestroyRWLock(mListenerLock);
  65     mListenerLock = nullptr;
  66   }
  67 }
  68
  69 already_AddRefed<RecorderProfileManager>
  70 CameraControlImpl::GetRecorderProfileManager()
  71 {
  72   return GetRecorderProfileManagerImpl();
  73 }
  74
  75 void
  76 CameraControlImpl::OnHardwareStateChange(CameraControlListener::HardwareState aNewState)
  77 {
  78   // This callback can run on threads other than the Main Thread and
  79   //  the Camera Thread. On Gonk, it may be called from the camera's
  80   //  local binder thread, should the mediaserver process die.
  81   RwLockAutoEnterRead lock(mListenerLock);
  82
  83   if (aNewState == mHardwareState) {
  84     DOM_CAMERA_LOGI("OnHardwareStateChange: state did not change from %d\n", mHardwareState);
  85     return;
  86   }
  87
  88 #ifdef PR_LOGGING
  89   const char* state[] = { "open", "closed", "failed" };
  90   MOZ_ASSERT(aNewState >= 0);
  91   if (static_cast<unsigned int>(aNewState) < sizeof(state) / sizeof(state[0])) {
  92     DOM_CAMERA_LOGI("New hardware state is '%s'\n", state[aNewState]);
  93   } else {
  94     DOM_CAMERA_LOGE("OnHardwareStateChange: got invalid HardwareState value %d\n", aNewState);
  95   }
  96 #endif
  97
  98   mHardwareState = aNewState;
  99
 100   for (uint32_t i = 0; i < mListeners.Length(); ++i) {
 101     CameraControlListener* l = mListeners[i];
 102     l->OnHardwareStateChange(mHardwareState);
 103   }
 104 }
 105
 106 void
 107 CameraControlImpl::OnConfigurationChange()
 108 {
 109   MOZ_ASSERT(NS_GetCurrentThread() == mCameraThread);
 110   RwLockAutoEnterRead lock(mListenerLock);
 111
 112   DOM_CAMERA_LOGI("OnConfigurationChange : %d listeners\n", mListeners.Length());
 113
 114   for (uint32_t i = 0; i < mListeners.Length(); ++i) {
 115     CameraControlListener* l = mListeners[i];
 116     l->OnConfigurationChange(mCurrentConfiguration);
 117   }
 118 }
 119
 120 void
 121 CameraControlImpl::OnAutoFocusComplete(bool aAutoFocusSucceeded)
 122 {
 123   // This callback can run on threads other than the Main Thread and
 124   //  the Camera Thread. On Gonk, it is called from the camera
 125   //  library's auto focus thread.
 126   RwLockAutoEnterRead lock(mListenerLock);
 127
 128   for (uint32_t i = 0; i < mListeners.Length(); ++i) {
 129     CameraControlListener* l = mListeners[i];
 130     l->OnAutoFocusComplete(aAutoFocusSucceeded);
 131   }
 132 }
 133
 134 void
 135 CameraControlImpl::OnAutoFocusMoving(bool aIsMoving)
 136 {
 137   RwLockAutoEnterRead lock(mListenerLock);
 138
 139   for (uint32_t i = 0; i < mListeners.Length(); ++i) {
 140     CameraControlListener* l = mListeners[i];
 141     l->OnAutoFocusMoving(aIsMoving);
 142   }
 143 }
 144
 145 void
 146 CameraControlImpl::OnFacesDetected(const nsTArray<Face>& aFaces)
 147 {
 148   // This callback can run on threads other than the Main Thread and
 149   //  the Camera Thread. On Gonk, it is called from the camera
 150   //  library's face detection thread.
 151   RwLockAutoEnterRead lock(mListenerLock);
 152
 153   for (uint32_t i = 0; i < mListeners.Length(); ++i) {
 154     CameraControlListener* l = mListeners[i];
 155     l->OnFacesDetected(aFaces);
 156   }
 157 }
 158
 159 void
 160 CameraControlImpl::OnTakePictureComplete(uint8_t* aData, uint32_t aLength, const nsAString& aMimeType)
 161 {
 162   // This callback can run on threads other than the Main Thread and
 163   //  the Camera Thread. On Gonk, it is called from the camera
 164   //  library's snapshot thread.
 165   RwLockAutoEnterRead lock(mListenerLock);
 166
 167   for (uint32_t i = 0; i < mListeners.Length(); ++i) {
 168     CameraControlListener* l = mListeners[i];
 169     l->OnTakePictureComplete(aData, aLength, aMimeType);
 170   }
 171 }
 172
 173 void
 174 CameraControlImpl::OnShutter()
 175 {
 176   // This callback can run on threads other than the Main Thread and
 177   //  the Camera Thread. On Gonk, it is called from the camera driver's
 178   //  preview thread.
 179   RwLockAutoEnterRead lock(mListenerLock);
 180
 181   for (uint32_t i = 0; i < mListeners.Length(); ++i) {
 182     CameraControlListener* l = mListeners[i];
 183     l->OnShutter();
 184   }
 185 }
 186
 187 void
 188 CameraControlImpl::OnClosed()
 189 {
 190   // This callback can run on threads other than the Main Thread and
 191   //  the Camera Thread.
 192   RwLockAutoEnterRead lock(mListenerLock);
 193
 194   for (uint32_t i = 0; i < mListeners.Length(); ++i) {
 195     CameraControlListener* l = mListeners[i];
 196     l->OnHardwareStateChange(CameraControlListener::kHardwareClosed);
 197   }
 198 }
 199
 200 void
 201 CameraControlImpl::OnRecorderStateChange(CameraControlListener::RecorderState aState,
 202                                          int32_t aStatus, int32_t aTrackNumber)
 203 {
 204   // This callback can run on threads other than the Main Thread and
 205   //  the Camera Thread. On Gonk, it is called from the media encoder
 206   //  thread.
 207   RwLockAutoEnterRead lock(mListenerLock);
 208
 209   for (uint32_t i = 0; i < mListeners.Length(); ++i) {
 210     CameraControlListener* l = mListeners[i];
 211     l->OnRecorderStateChange(aState, aStatus, aTrackNumber);
 212   }
 213 }
 214
 215 void
 216 CameraControlImpl::OnPreviewStateChange(CameraControlListener::PreviewState aNewState)
 217 {
 218   // This callback runs on the Main Thread and the Camera Thread, and
 219   //  may run on the local binder thread, should the mediaserver
 220   //  process die.
 221   RwLockAutoEnterRead lock(mListenerLock);
 222
 223   if (aNewState == mPreviewState) {
 224     DOM_CAMERA_LOGI("OnPreviewStateChange: state did not change from %d\n", mPreviewState);
 225     return;
 226   }
 227
 228 #ifdef PR_LOGGING
 229   const char* state[] = { "stopped", "paused", "started" };
 230   MOZ_ASSERT(aNewState >= 0);
 231   if (static_cast<unsigned int>(aNewState) < sizeof(state) / sizeof(state[0])) {
 232     DOM_CAMERA_LOGI("New preview state is '%s'\n", state[aNewState]);
 233   } else {
 234     DOM_CAMERA_LOGE("OnPreviewStateChange: got unknown PreviewState value %d\n", aNewState);
 235   }
 236 #endif
 237
 238   mPreviewState = aNewState;
 239
 240   for (uint32_t i = 0; i < mListeners.Length(); ++i) {
 241     CameraControlListener* l = mListeners[i];
 242     l->OnPreviewStateChange(mPreviewState);
 243   }
 244 }
 245
 246 void
 247 CameraControlImpl::OnRateLimitPreview(bool aLimit)
 248 {
 249   // This function runs on neither the Main Thread nor the Camera Thread.
 250   RwLockAutoEnterRead lock(mListenerLock);
 251
 252   DOM_CAMERA_LOGI("OnRateLimitPreview: %d\n", aLimit);
 253
 254   for (uint32_t i = 0; i < mListeners.Length(); ++i) {
 255     CameraControlListener* l = mListeners[i];
 256     l->OnRateLimitPreview(aLimit);
 257   }
 258 }
 259
 260 bool
 261 CameraControlImpl::OnNewPreviewFrame(layers::Image* aImage, uint32_t aWidth, uint32_t aHeight)
 262 {
 263   // This function runs on neither the Main Thread nor the Camera Thread.
 264   //  On Gonk, it is called from the camera driver's preview thread.
 265   RwLockAutoEnterRead lock(mListenerLock);
 266
 267   DOM_CAMERA_LOGI("OnNewPreviewFrame: we have %d preview frame listener(s)\n",
 268     mListeners.Length());
 269
 270   bool consumed = false;
 271
 272   for (uint32_t i = 0; i < mListeners.Length(); ++i) {
 273     CameraControlListener* l = mListeners[i];
 274     consumed = l->OnNewPreviewFrame(aImage, aWidth, aHeight) || consumed;
 275   }
 276   return consumed;
 277 }
 278
 279 void
 280 CameraControlImpl::OnUserError(CameraControlListener::UserContext aContext,
 281                                nsresult aError)
 282 {
 283   // This callback can run on threads other than the Main Thread and
 284   //  the Camera Thread.
 285   RwLockAutoEnterRead lock(mListenerLock);
 286
 287 #ifdef PR_LOGGING
 288   const char* context[] = {
 289     "StartCamera",
 290     "StopCamera",
 291     "AutoFocus",
 292     "StartFaceDetection",
 293     "StopFaceDetection",
 294     "TakePicture",
 295     "StartRecording",
 296     "StopRecording",
 297     "SetConfiguration",
 298     "StartPreview",
 299     "StopPreview",
 300     "SetPictureSize",
 301     "SetThumbnailSize",
 302     "ResumeContinuousFocus",
 303     "Unspecified"
 304   };
 305   if (static_cast<size_t>(aContext) < sizeof(context) / sizeof(context[0])) {
 306     DOM_CAMERA_LOGW("CameraControlImpl::OnUserError : aContext='%s' (%d), aError=0x%x\n",
 307       context[aContext], aContext, aError);
 308   } else {
 309     DOM_CAMERA_LOGE("CameraControlImpl::OnUserError : aContext=%d, aError=0x%x\n",
 310       aContext, aError);
 311   }
 312 #endif
 313
 314   for (uint32_t i = 0; i < mListeners.Length(); ++i) {
 315     CameraControlListener* l = mListeners[i];
 316     l->OnUserError(aContext, aError);
 317   }
 318 }
 319
 320 void
 321 CameraControlImpl::OnSystemError(CameraControlListener::SystemContext aContext,
 322                                  nsresult aError)
 323 {
 324   // This callback can run on threads other than the Main Thread and
 325   //  the Camera Thread.
 326   RwLockAutoEnterRead lock(mListenerLock);
 327
 328 #ifdef PR_LOGGING
 329   const char* context[] = {
 330     "Camera Service"
 331   };
 332   if (static_cast<size_t>(aContext) < sizeof(context) / sizeof(context[0])) {
 333     DOM_CAMERA_LOGW("CameraControlImpl::OnSystemError : aContext='%s' (%d), aError=0x%x\n",
 334       context[aContext], aContext, aError);
 335   } else {
 336     DOM_CAMERA_LOGE("CameraControlImpl::OnSystemError : aContext=%d, aError=0x%x\n",
 337       aContext, aError);
 338   }
 339 #endif
 340
 341   for (uint32_t i = 0; i < mListeners.Length(); ++i) {
 342     CameraControlListener* l = mListeners[i];
 343     l->OnSystemError(aContext, aError);
 344   }
 345 }
 346
 347 // Camera control asynchronous message; these are dispatched from
 348 //  the Main Thread to the Camera Thread, where they are consumed.
 349
 350 class CameraControlImpl::ControlMessage : public nsRunnable
 351 {
 352 public:
 353   ControlMessage(CameraControlImpl* aCameraControl,
 354                  CameraControlListener::UserContext aContext)
 355     : mCameraControl(aCameraControl)
 356     , mContext(aContext)
 357   { }
 358
 359   virtual nsresult RunImpl() = 0;
 360
 361   NS_IMETHOD
 362   Run() MOZ_OVERRIDE
 363   {
 364     MOZ_ASSERT(mCameraControl);
 365     MOZ_ASSERT(NS_GetCurrentThread() == mCameraControl->mCameraThread);
 366
 367     nsresult rv = RunImpl();
 368     if (NS_FAILED(rv)) {
 369       nsPrintfCString msg("Camera control API(%d) failed with 0x%x", mContext, rv);
 370       NS_WARNING(msg.get());
 371       mCameraControl->OnUserError(mContext, rv);
 372     }
 373
 374     return NS_OK;
 375   }
 376
 377 protected:
 378   virtual ~ControlMessage() { }
 379
 380   nsRefPtr<CameraControlImpl> mCameraControl;
 381   CameraControlListener::UserContext mContext;
 382 };
 383
 384 nsresult
 385 CameraControlImpl::Dispatch(ControlMessage* aMessage)
 386 {
 387   nsresult rv = mCameraThread->Dispatch(aMessage, NS_DISPATCH_NORMAL);
 388   if (NS_SUCCEEDED(rv)) {
 389     return NS_OK;
 390   }
 391
 392   nsPrintfCString msg("Failed to dispatch camera control message (0x%x)", rv);
 393   NS_WARNING(msg.get());
 394   return NS_ERROR_FAILURE;
 395 }
 396
 397 nsresult
 398 CameraControlImpl::Start(const Configuration* aConfig)
 399 {
 400   class Message : public ControlMessage
 401   {
 402   public:
 403     Message(CameraControlImpl* aCameraControl,
 404             CameraControlListener::UserContext aContext,
 405             const Configuration* aConfig)
 406       : ControlMessage(aCameraControl, aContext)
 407       , mHaveInitialConfig(false)
 408     {
 409       if (aConfig) {
 410         mConfig = *aConfig;
 411         mHaveInitialConfig = true;
 412       }
 413     }
 414
 415     nsresult
 416     RunImpl() MOZ_OVERRIDE
 417     {
 418       if (mHaveInitialConfig) {
 419         return mCameraControl->StartImpl(&mConfig);
 420       }
 421       return mCameraControl->StartImpl();
 422     }
 423
 424   protected:
 425     bool mHaveInitialConfig;
 426     Configuration mConfig;
 427   };
 428
 429   return Dispatch(new Message(this, CameraControlListener::kInStartCamera, aConfig));
 430 }
 431
 432 nsresult
 433 CameraControlImpl::SetConfiguration(const Configuration& aConfig)
 434 {
 435   class Message : public ControlMessage
 436   {
 437   public:
 438     Message(CameraControlImpl* aCameraControl,
 439             CameraControlListener::UserContext aContext,
 440             const Configuration& aConfig)
 441       : ControlMessage(aCameraControl, aContext)
 442       , mConfig(aConfig)
 443     { }
 444
 445     nsresult
 446     RunImpl() MOZ_OVERRIDE
 447     {
 448       return mCameraControl->SetConfigurationImpl(mConfig);
 449     }
 450
 451   protected:
 452     Configuration mConfig;
 453   };
 454
 455   return Dispatch(new Message(this, CameraControlListener::kInSetConfiguration, aConfig));
 456 }
 457
 458 nsresult
 459 CameraControlImpl::AutoFocus()
 460 {
 461   class Message : public ControlMessage
 462   {
 463   public:
 464     Message(CameraControlImpl* aCameraControl,
 465             CameraControlListener::UserContext aContext)
 466       : ControlMessage(aCameraControl, aContext)
 467     { }
 468
 469     nsresult
 470     RunImpl() MOZ_OVERRIDE
 471     {
 472       return mCameraControl->AutoFocusImpl();
 473     }
 474   };
 475
 476   return Dispatch(new Message(this, CameraControlListener::kInAutoFocus));
 477 }
 478
 479 nsresult
 480 CameraControlImpl::StartFaceDetection()
 481 {
 482   class Message : public ControlMessage
 483   {
 484   public:
 485     Message(CameraControlImpl* aCameraControl,
 486             CameraControlListener::UserContext aContext)
 487       : ControlMessage(aCameraControl, aContext)
 488     { }
 489
 490     nsresult
 491     RunImpl() MOZ_OVERRIDE
 492     {
 493       return mCameraControl->StartFaceDetectionImpl();
 494     }
 495   };
 496
 497   return Dispatch(new Message(this, CameraControlListener::kInStartFaceDetection));
 498 }
 499
 500 nsresult
 501 CameraControlImpl::StopFaceDetection()
 502 {
 503   class Message : public ControlMessage
 504   {
 505   public:
 506     Message(CameraControlImpl* aCameraControl,
 507             CameraControlListener::UserContext aContext)
 508       : ControlMessage(aCameraControl, aContext)
 509     { }
 510
 511     nsresult
 512     RunImpl() MOZ_OVERRIDE
 513     {
 514       return mCameraControl->StopFaceDetectionImpl();
 515     }
 516   };
 517
 518   return Dispatch(new Message(this, CameraControlListener::kInStopFaceDetection));
 519 }
 520
 521 nsresult
 522 CameraControlImpl::TakePicture()
 523 {
 524   class Message : public ControlMessage
 525   {
 526   public:
 527     Message(CameraControlImpl* aCameraControl,
 528             CameraControlListener::UserContext aContext)
 529       : ControlMessage(aCameraControl, aContext)
 530     { }
 531
 532     nsresult
 533     RunImpl() MOZ_OVERRIDE
 534     {
 535       return mCameraControl->TakePictureImpl();
 536     }
 537   };
 538
 539   return Dispatch(new Message(this, CameraControlListener::kInTakePicture));
 540 }
 541
 542 nsresult
 543 CameraControlImpl::StartRecording(DeviceStorageFileDescriptor* aFileDescriptor,
 544                                   const StartRecordingOptions* aOptions)
 545 {
 546   class Message : public ControlMessage
 547   {
 548   public:
 549     Message(CameraControlImpl* aCameraControl,
 550             CameraControlListener::UserContext aContext,
 551             const StartRecordingOptions* aOptions,
 552             DeviceStorageFileDescriptor* aFileDescriptor)
 553       : ControlMessage(aCameraControl, aContext)
 554       , mOptionsPassed(false)
 555       , mFileDescriptor(aFileDescriptor)
 556     {
 557       if (aOptions) {
 558         mOptions = *aOptions;
 559         mOptionsPassed = true;
 560       }
 561     }
 562
 563     nsresult
 564     RunImpl() MOZ_OVERRIDE
 565     {
 566       return mCameraControl->StartRecordingImpl(mFileDescriptor,
 567         mOptionsPassed ? &mOptions : nullptr);
 568     }
 569
 570   protected:
 571     StartRecordingOptions mOptions;
 572     bool mOptionsPassed;
 573     nsRefPtr<DeviceStorageFileDescriptor> mFileDescriptor;
 574   };
 575
 576   if (!aFileDescriptor) {
 577     return NS_ERROR_INVALID_ARG;
 578   }
 579   return Dispatch(new Message(this, CameraControlListener::kInStartRecording,
 580     aOptions, aFileDescriptor));
 581 }
 582
 583 nsresult
 584 CameraControlImpl::StopRecording()
 585 {
 586   class Message : public ControlMessage
 587   {
 588   public:
 589     Message(CameraControlImpl* aCameraControl,
 590             CameraControlListener::UserContext aContext)
 591       : ControlMessage(aCameraControl, aContext)
 592     { }
 593
 594     nsresult
 595     RunImpl() MOZ_OVERRIDE
 596     {
 597       return mCameraControl->StopRecordingImpl();
 598     }
 599   };
 600
 601   return Dispatch(new Message(this, CameraControlListener::kInStopRecording));
 602 }
 603
 604 nsresult
 605 CameraControlImpl::StartPreview()
 606 {
 607   class Message : public ControlMessage
 608   {
 609   public:
 610     Message(CameraControlImpl* aCameraControl,
 611             CameraControlListener::UserContext aContext)
 612       : ControlMessage(aCameraControl, aContext)
 613     { }
 614
 615     nsresult
 616     RunImpl() MOZ_OVERRIDE
 617     {
 618       return mCameraControl->StartPreviewImpl();
 619     }
 620   };
 621
 622   return Dispatch(new Message(this, CameraControlListener::kInStartPreview));
 623 }
 624
 625 nsresult
 626 CameraControlImpl::StopPreview()
 627 {
 628   class Message : public ControlMessage
 629   {
 630   public:
 631     Message(CameraControlImpl* aCameraControl,
 632             CameraControlListener::UserContext aContext)
 633       : ControlMessage(aCameraControl, aContext)
 634     { }
 635
 636     nsresult
 637     RunImpl() MOZ_OVERRIDE
 638     {
 639       return mCameraControl->StopPreviewImpl();
 640     }
 641   };
 642
 643   return Dispatch(new Message(this, CameraControlListener::kInStopPreview));
 644 }
 645
 646 nsresult
 647 CameraControlImpl::ResumeContinuousFocus()
 648 {
 649   class Message : public ControlMessage
 650   {
 651   public:
 652     Message(CameraControlImpl* aCameraControl,
 653             CameraControlListener::UserContext aContext)
 654       : ControlMessage(aCameraControl, aContext)
 655     { }
 656
 657     nsresult
 658     RunImpl() MOZ_OVERRIDE
 659     {
 660       return mCameraControl->ResumeContinuousFocusImpl();
 661     }
 662   };
 663
 664   return Dispatch(new Message(this, CameraControlListener::kInResumeContinuousFocus));
 665 }
 666
 667 nsresult
 668 CameraControlImpl::Stop()
 669 {
 670   class Message : public ControlMessage
 671   {
 672   public:
 673     Message(CameraControlImpl* aCameraControl,
 674             CameraControlListener::UserContext aContext)
 675       : ControlMessage(aCameraControl, aContext)
 676     { }
 677
 678     nsresult
 679     RunImpl() MOZ_OVERRIDE
 680     {
 681       return mCameraControl->StopImpl();
 682     }
 683   };
 684
 685   return Dispatch(new Message(this, CameraControlListener::kInStopCamera));
 686 }
 687
 688 class CameraControlImpl::ListenerMessage : public CameraControlImpl::ControlMessage
 689 {
 690 public:
 691   ListenerMessage(CameraControlImpl* aCameraControl,
 692                   CameraControlListener* aListener)
 693     : ControlMessage(aCameraControl, CameraControlListener::kInUnspecified)
 694     , mListener(aListener)
 695   { }
 696
 697 protected:
 698   nsRefPtr<CameraControlListener> mListener;
 699 };
 700
 701 void
 702 CameraControlImpl::AddListenerImpl(already_AddRefed<CameraControlListener> aListener)
 703 {
 704   RwLockAutoEnterWrite lock(mListenerLock);
 705
 706   CameraControlListener* l = *mListeners.AppendElement() = aListener;
 707   DOM_CAMERA_LOGI("Added camera control listener %p\n", l);
 708
 709   // Update the newly-added listener's state
 710   l->OnConfigurationChange(mCurrentConfiguration);
 711   l->OnHardwareStateChange(mHardwareState);
 712   l->OnPreviewStateChange(mPreviewState);
 713 }
 714
 715 void
 716 CameraControlImpl::AddListener(CameraControlListener* aListener)
 717  {
 718   class Message : public ListenerMessage
 719   {
 720   public:
 721     Message(CameraControlImpl* aCameraControl,
 722             CameraControlListener* aListener)
 723       : ListenerMessage(aCameraControl, aListener)
 724     { }
 725
 726     nsresult
 727     RunImpl() MOZ_OVERRIDE
 728     {
 729       mCameraControl->AddListenerImpl(mListener.forget());
 730       return NS_OK;
 731     }
 732   };
 733
 734   if (aListener) {
 735     Dispatch(new Message(this, aListener));
 736   }
 737 }
 738
 739 void
 740 CameraControlImpl::RemoveListenerImpl(CameraControlListener* aListener)
 741 {
 742   RwLockAutoEnterWrite lock(mListenerLock);
 743
 744   nsRefPtr<CameraControlListener> l(aListener);
 745   mListeners.RemoveElement(l);
 746   DOM_CAMERA_LOGI("Removed camera control listener %p\n", l.get());
 747   // XXXmikeh - do we want to notify the listener that it has been removed?
 748 }
 749
 750 void
 751 CameraControlImpl::RemoveListener(CameraControlListener* aListener)
 752  {
 753   class Message : public ListenerMessage
 754   {
 755   public:
 756     Message(CameraControlImpl* aCameraControl, CameraControlListener* aListener)
 757       : ListenerMessage(aCameraControl, aListener)
 758     { }
 759
 760     nsresult
 761     RunImpl() MOZ_OVERRIDE
 762     {
 763       mCameraControl->RemoveListenerImpl(mListener);
 764       return NS_OK;
 765     }
 766   };
 767
 768   if (aListener) {
 769     Dispatch(new Message(this, aListener));
 770   }
 771 }