Bug 1259290: Part 5 - Remove the cx from WorkerFeature::Notify. r=bz
authorKyle Huey <khuey@kylehuey.com>
Mon, 28 Mar 2016 10:28:14 -0700
changeset 290738 e979e75c94f650e3a1ecf4b3416a8ab605edb417
parent 290737 a4dbc5475d87762085ac168a1c701a35e16016f7
child 290739 932e732dedfed03fcaff46b699ac3c6efb50738d
push id19656
push usergwagner@mozilla.com
push dateMon, 04 Apr 2016 13:43:23 +0000
treeherderb2g-inbound@e99061fde28a [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbz
bugs1259290
milestone48.0a1
Bug 1259290: Part 5 - Remove the cx from WorkerFeature::Notify. r=bz
dom/base/Console.cpp
dom/base/FileReader.cpp
dom/base/FileReader.h
dom/base/WebSocket.cpp
dom/broadcastchannel/BroadcastChannel.cpp
dom/cache/Feature.cpp
dom/cache/Feature.h
dom/canvas/WebGLContextLossHandler.cpp
dom/canvas/WebGLContextLossHandler.h
dom/fetch/Fetch.cpp
dom/indexedDB/ActorsChild.cpp
dom/indexedDB/IDBRequest.cpp
dom/indexedDB/IDBTransaction.cpp
dom/messagechannel/MessagePort.cpp
dom/notification/Notification.cpp
dom/notification/Notification.h
dom/promise/Promise.cpp
dom/promise/Promise.h
dom/promise/PromiseWorkerProxy.h
dom/workers/DataStore.cpp
dom/workers/DataStore.h
dom/workers/ScriptLoader.cpp
dom/workers/ServiceWorkerPrivate.cpp
dom/workers/ServiceWorkerRegistration.cpp
dom/workers/ServiceWorkerRegistration.h
dom/workers/WorkerFeature.h
dom/workers/WorkerPrivate.cpp
dom/workers/XMLHttpRequest.cpp
dom/workers/XMLHttpRequest.h
--- a/dom/base/Console.cpp
+++ b/dom/base/Console.cpp
@@ -328,17 +328,17 @@ public:
     if (!DispatchInternal(aCx)) {
       ReleaseData();
       return false;
     }
 
     return true;
   }
 
-  virtual bool Notify(JSContext* aCx, workers::Status aStatus) override
+  virtual bool Notify(workers::Status aStatus) override
   {
     // We don't care about the notification. We just want to keep the
     // mWorkerPrivate alive.
     return true;
   }
 
 private:
   NS_IMETHOD
--- a/dom/base/FileReader.cpp
+++ b/dom/base/FileReader.cpp
@@ -713,17 +713,17 @@ FileReader::DecreaseBusyCounter()
 {
   MOZ_ASSERT_IF(mWorkerPrivate, mBusyCount);
   if (mWorkerPrivate && --mBusyCount == 0) {
     mWorkerPrivate->RemoveFeature(this);
   }
 }
 
 bool
-FileReader::Notify(JSContext* aCx, Status aStatus)
+FileReader::Notify(Status aStatus)
 {
   MOZ_ASSERT(mWorkerPrivate);
   mWorkerPrivate->AssertIsOnWorkerThread();
 
   if (aStatus > Running) {
     Shutdown();
   }
 
--- a/dom/base/FileReader.h
+++ b/dom/base/FileReader.h
@@ -102,17 +102,17 @@ public:
   IMPL_EVENT_HANDLER(loadend)
 
   void ReadAsBinaryString(Blob& aBlob, ErrorResult& aRv)
   {
     ReadFileContent(aBlob, EmptyString(), FILE_AS_BINARY, aRv);
   }
 
   // WorkerFeature
-  bool Notify(JSContext* aCx, workers::Status) override;
+  bool Notify(workers::Status) override;
 
 private:
   virtual ~FileReader();
 
   // This must be in sync with dom/webidl/FileReader.webidl
   enum eReadyState {
     EMPTY = 0,
     LOADING = 1,
--- a/dom/base/WebSocket.cpp
+++ b/dom/base/WebSocket.cpp
@@ -2142,17 +2142,17 @@ namespace {
 class WebSocketWorkerFeature final : public WorkerFeature
 {
 public:
   explicit WebSocketWorkerFeature(WebSocketImpl* aWebSocketImpl)
     : mWebSocketImpl(aWebSocketImpl)
   {
   }
 
-  bool Notify(JSContext* aCx, Status aStatus) override
+  bool Notify(Status aStatus) override
   {
     MOZ_ASSERT(aStatus > workers::Running);
 
     if (aStatus >= Canceling) {
       {
         MutexAutoLock lock(mWebSocketImpl->mMutex);
         mWebSocketImpl->mWorkerShuttingDown = true;
       }
--- a/dom/broadcastchannel/BroadcastChannel.cpp
+++ b/dom/broadcastchannel/BroadcastChannel.cpp
@@ -276,17 +276,17 @@ class BroadcastChannelFeature final : pu
 
 public:
   explicit BroadcastChannelFeature(BroadcastChannel* aChannel)
     : mChannel(aChannel)
   {
     MOZ_COUNT_CTOR(BroadcastChannelFeature);
   }
 
-  virtual bool Notify(JSContext* aCx, workers::Status aStatus) override
+  virtual bool Notify(workers::Status aStatus) override
   {
     if (aStatus >= Closing) {
       mChannel->Shutdown();
     }
 
     return true;
   }
 
--- a/dom/cache/Feature.cpp
+++ b/dom/cache/Feature.cpp
@@ -64,17 +64,17 @@ Feature::RemoveActor(ActorChild* aActor)
 
 bool
 Feature::Notified() const
 {
   return mNotified;
 }
 
 bool
-Feature::Notify(JSContext* aCx, Status aStatus)
+Feature::Notify(Status aStatus)
 {
   NS_ASSERT_OWNINGTHREAD(Feature);
 
   // When the service worker thread is stopped we will get Terminating,
   // but nothing higher than that.  We must shut things down at Terminating.
   if (aStatus < Terminating || mNotified) {
     return true;
   }
--- a/dom/cache/Feature.h
+++ b/dom/cache/Feature.h
@@ -28,17 +28,17 @@ public:
   static already_AddRefed<Feature> Create(workers::WorkerPrivate* aWorkerPrivate);
 
   void AddActor(ActorChild* aActor);
   void RemoveActor(ActorChild* aActor);
 
   bool Notified() const;
 
   // WorkerFeature methods
-  virtual bool Notify(JSContext* aCx, workers::Status aStatus) override;
+  virtual bool Notify(workers::Status aStatus) override;
 
 private:
   explicit Feature(workers::WorkerPrivate *aWorkerPrivate);
   ~Feature();
 
   workers::WorkerPrivate* mWorkerPrivate;
   nsTArray<ActorChild*> mActorList;
   bool mNotified;
--- a/dom/canvas/WebGLContextLossHandler.cpp
+++ b/dom/canvas/WebGLContextLossHandler.cpp
@@ -219,17 +219,17 @@ WebGLContextLossHandler::DisableTimer()
 
     if (!mIsTimerRunning)
         return;
 
     mTimer->SetDelay(0);
 }
 
 bool
-WebGLContextLossHandler::Notify(JSContext* aCx, dom::workers::Status aStatus)
+WebGLContextLossHandler::Notify(dom::workers::Status aStatus)
 {
     bool isWorkerRunning = aStatus < dom::workers::Closing;
     if (!isWorkerRunning && mIsTimerRunning) {
         mIsTimerRunning = false;
         this->Release();
     }
 
     return true;
--- a/dom/canvas/WebGLContextLossHandler.h
+++ b/dom/canvas/WebGLContextLossHandler.h
@@ -32,17 +32,17 @@ class WebGLContextLossHandler : public d
 
 public:
     NS_INLINE_DECL_REFCOUNTING(WebGLContextLossHandler)
 
     explicit WebGLContextLossHandler(WebGLContext* webgl);
 
     void RunTimer();
     void DisableTimer();
-    bool Notify(JSContext* aCx, dom::workers::Status aStatus) override;
+    bool Notify(dom::workers::Status aStatus) override;
 
 protected:
     ~WebGLContextLossHandler();
 
     void StartTimer(unsigned long delayMS);
     static void StaticTimerCallback(nsITimer*, void* tempRefForTimer);
     void TimerCallback();
 };
--- a/dom/fetch/Fetch.cpp
+++ b/dom/fetch/Fetch.cpp
@@ -735,17 +735,17 @@ public:
   explicit FetchBodyFeature(FetchBody<Derived>* aBody)
     : mBody(aBody)
     , mWasNotified(false)
   { }
 
   ~FetchBodyFeature()
   { }
 
-  bool Notify(JSContext* aCx, workers::Status aStatus) override
+  bool Notify(workers::Status aStatus) override
   {
     MOZ_ASSERT(aStatus > workers::Running);
     if (!mWasNotified) {
       mWasNotified = true;
       mBody->ContinueConsumeBody(NS_BINDING_ABORTED, 0, nullptr);
     }
     return true;
   }
--- a/dom/indexedDB/ActorsChild.cpp
+++ b/dom/indexedDB/ActorsChild.cpp
@@ -924,17 +924,17 @@ public:
     if (completed) {
       OperationCompleted();
     }
 
     return NS_OK;
   }
 
   virtual bool
-  Notify(JSContext* aCx, workers::Status aStatus) override
+  Notify(workers::Status aStatus) override
   {
     // We don't care about the notification. We just want to keep the
     // mWorkerPrivate alive.
     return true;
   }
 
   void
   OperationCompleted()
--- a/dom/indexedDB/IDBRequest.cpp
+++ b/dom/indexedDB/IDBRequest.cpp
@@ -503,17 +503,17 @@ public:
     MOZ_ASSERT(mWorkerPrivate);
     mWorkerPrivate->AssertIsOnWorkerThread();
 
     mWorkerPrivate = nullptr;
   }
 
 private:
   virtual bool
-  Notify(JSContext* aCx, Status aStatus) override;
+  Notify(Status aStatus) override;
 };
 
 IDBOpenDBRequest::IDBOpenDBRequest(IDBFactory* aFactory,
                                    nsPIDOMWindowInner* aOwner,
                                    bool aFileHandleDisabled)
   : IDBRequest(aOwner)
   , mFactory(aFactory)
   , mFileHandleDisabled(aFileHandleDisabled)
@@ -644,17 +644,17 @@ IDBOpenDBRequest::WrapObject(JSContext* 
 {
   AssertIsOnOwningThread();
 
   return IDBOpenDBRequestBinding::Wrap(aCx, this, aGivenProto);
 }
 
 bool
 IDBOpenDBRequest::
-WorkerFeature::Notify(JSContext* aCx, Status aStatus)
+WorkerFeature::Notify(Status aStatus)
 {
   MOZ_ASSERT(mWorkerPrivate);
   mWorkerPrivate->AssertIsOnWorkerThread();
   MOZ_ASSERT(aStatus > Running);
 
   // There's nothing we can really do here at the moment...
   NS_WARNING("Worker closing but IndexedDB is waiting to open a database!");
 
--- a/dom/indexedDB/IDBTransaction.cpp
+++ b/dom/indexedDB/IDBTransaction.cpp
@@ -62,17 +62,17 @@ public:
 
     MOZ_COUNT_DTOR(IDBTransaction::WorkerFeature);
 
     mWorkerPrivate->RemoveFeature(this);
   }
 
 private:
   virtual bool
-  Notify(JSContext* aCx, Status aStatus) override;
+  Notify(Status aStatus) override;
 };
 
 IDBTransaction::IDBTransaction(IDBDatabase* aDatabase,
                                const nsTArray<nsString>& aObjectStoreNames,
                                Mode aMode)
   : IDBWrapperCache(aDatabase)
   , mDatabase(aDatabase)
   , mObjectStoreNames(aObjectStoreNames)
@@ -988,17 +988,17 @@ IDBTransaction::Run()
     SendCommit();
   }
 
   return NS_OK;
 }
 
 bool
 IDBTransaction::
-WorkerFeature::Notify(JSContext* aCx, Status aStatus)
+WorkerFeature::Notify(Status aStatus)
 {
   MOZ_ASSERT(mWorkerPrivate);
   mWorkerPrivate->AssertIsOnWorkerThread();
   MOZ_ASSERT(aStatus > Running);
 
   if (mTransaction && aStatus > Terminating) {
     mTransaction->AssertIsOnOwningThread();
 
--- a/dom/messagechannel/MessagePort.cpp
+++ b/dom/messagechannel/MessagePort.cpp
@@ -206,17 +206,17 @@ class MessagePortFeature final : public 
 public:
   explicit MessagePortFeature(MessagePort* aPort)
     : mPort(aPort)
   {
     MOZ_ASSERT(aPort);
     MOZ_COUNT_CTOR(MessagePortFeature);
   }
 
-  virtual bool Notify(JSContext* aCx, workers::Status aStatus) override
+  virtual bool Notify(workers::Status aStatus) override
   {
     if (aStatus > Running) {
       // We cannot process messages anymore because we cannot dispatch new
       // runnables. Let's force a Close().
       mPort->CloseForced();
     }
 
     return true;
--- a/dom/notification/Notification.cpp
+++ b/dom/notification/Notification.cpp
@@ -2467,17 +2467,17 @@ class CloseNotificationRunnable final
   bool
   HadObserver()
   {
     return mHadObserver;
   }
 };
 
 bool
-NotificationFeature::Notify(JSContext* aCx, Status aStatus)
+NotificationFeature::Notify(Status aStatus)
 {
   if (aStatus >= Canceling) {
     // CloseNotificationRunnable blocks the worker by pushing a sync event loop
     // on the stack. Meanwhile, WorkerControlRunnables dispatched to the worker
     // can still continue running. One of these is
     // ReleaseNotificationControlRunnable that releases the notification,
     // invalidating the notification and this feature. We hold this reference to
     // keep the notification valid until we are done with it.
--- a/dom/notification/Notification.h
+++ b/dom/notification/Notification.h
@@ -41,17 +41,17 @@ class NotificationFeature final : public
   // Since the feature is strongly held by a Notification, it is ok to hold
   // a raw pointer here.
   Notification* mNotification;
 
 public:
   explicit NotificationFeature(Notification* aNotification);
 
   bool
-  Notify(JSContext* aCx, workers::Status aStatus) override;
+  Notify(workers::Status aStatus) override;
 };
 
 // Records telemetry probes at application startup, when a notification is
 // shown, and when the notification permission is revoked for a site.
 class NotificationTelemetryService final : public nsIObserver
 {
 public:
   NS_DECL_ISUPPORTS
--- a/dom/promise/Promise.cpp
+++ b/dom/promise/Promise.cpp
@@ -2724,17 +2724,17 @@ Promise::RemoveFeature()
     workers::WorkerPrivate* worker = GetCurrentThreadWorkerPrivate();
     MOZ_ASSERT(worker);
     worker->RemoveFeature(mFeature);
     mFeature = nullptr;
   }
 }
 
 bool
-PromiseReportRejectFeature::Notify(JSContext* aCx, workers::Status aStatus)
+PromiseReportRejectFeature::Notify(workers::Status aStatus)
 {
   MOZ_ASSERT(aStatus > workers::Running);
   mPromise->MaybeReportRejectedOnce();
   // After this point, `this` has been deleted by RemoveFeature!
   return true;
 }
 #endif // defined(DOM_PROMISE_DEPRECATED_REPORTING)
 
@@ -2987,17 +2987,17 @@ PromiseWorkerProxy::ResolvedCallback(JSC
 void
 PromiseWorkerProxy::RejectedCallback(JSContext* aCx,
                                      JS::Handle<JS::Value> aValue)
 {
   RunCallback(aCx, aValue, &Promise::MaybeReject);
 }
 
 bool
-PromiseWorkerProxy::Notify(JSContext* aCx, Status aStatus)
+PromiseWorkerProxy::Notify(Status aStatus)
 {
   if (aStatus >= Canceling) {
     CleanUp();
   }
 
   return true;
 }
 
--- a/dom/promise/Promise.h
+++ b/dom/promise/Promise.h
@@ -57,17 +57,17 @@ class PromiseReportRejectFeature : publi
 public:
   explicit PromiseReportRejectFeature(Promise* aPromise)
     : mPromise(aPromise)
   {
     MOZ_ASSERT(mPromise);
   }
 
   virtual bool
-  Notify(JSContext* aCx, workers::Status aStatus) override;
+  Notify(workers::Status aStatus) override;
 };
 #endif // defined(DOM_PROMISE_DEPRECATED_REPORTING)
 
 #define NS_PROMISE_IID \
   { 0x1b8d6215, 0x3e67, 0x43ba, \
     { 0x8a, 0xf9, 0x31, 0x5e, 0x8f, 0xce, 0x75, 0x65 } }
 
 class Promise : public nsISupports,
--- a/dom/promise/PromiseWorkerProxy.h
+++ b/dom/promise/PromiseWorkerProxy.h
@@ -180,17 +180,17 @@ public:
 
 protected:
   virtual void ResolvedCallback(JSContext* aCx,
                                 JS::Handle<JS::Value> aValue) override;
 
   virtual void RejectedCallback(JSContext* aCx,
                                 JS::Handle<JS::Value> aValue) override;
 
-  virtual bool Notify(JSContext* aCx, workers::Status aStatus) override;
+  virtual bool Notify(workers::Status aStatus) override;
 
 private:
   PromiseWorkerProxy(workers::WorkerPrivate* aWorkerPrivate,
                      Promise* aWorkerPromise,
                      const PromiseWorkerProxyStructuredCloneCallbacks* aCallbacks = nullptr);
 
   virtual ~PromiseWorkerProxy();
 
--- a/dom/workers/DataStore.cpp
+++ b/dom/workers/DataStore.cpp
@@ -957,29 +957,28 @@ DataStoreChangeEventProxy::HandleEvent(n
   runnable->Dispatch();
 
   return NS_OK;
 }
 
 // WorkerFeature implementation.
 
 bool
-DataStoreChangeEventProxy::Notify(JSContext* aCx, Status aStatus)
+DataStoreChangeEventProxy::Notify(Status aStatus)
 {
   MutexAutoLock lock(mCleanUpLock);
 
   // |mWorkerPrivate| might not be safe to use anymore if we have already
   // cleaned up and RemoveFeature(), so we need to check |mCleanedUp| first.
   if (mCleanedUp) {
     return true;
   }
 
   MOZ_ASSERT(mWorkerPrivate);
   mWorkerPrivate->AssertIsOnWorkerThread();
-  MOZ_ASSERT(mWorkerPrivate->GetJSContext() == aCx);
 
   // Release the WorkerStore and remove the DataStoreChangeEventProxy from the
   // features of the worker thread since the worker thread has been cancelled.
   if (aStatus >= Canceling) {
     mWorkerStore = nullptr;
     mWorkerPrivate->RemoveFeature(this);
     mCleanedUp = true;
   }
--- a/dom/workers/DataStore.h
+++ b/dom/workers/DataStore.h
@@ -111,17 +111,17 @@ public:
 
   WorkerPrivate* GetWorkerPrivate() const;
 
   WorkerDataStore* GetWorkerStore() const;
 
 protected:
   // WorkerFeature implementation.
 
-  bool Notify(JSContext* aCx, Status aStatus) override;
+  bool Notify(Status aStatus) override;
 
 private:
   ~DataStoreChangeEventProxy() {};
 
   WorkerPrivate* mWorkerPrivate;
 
   RefPtr<WorkerDataStore> mWorkerStore;
 
--- a/dom/workers/ScriptLoader.cpp
+++ b/dom/workers/ScriptLoader.cpp
@@ -703,17 +703,17 @@ private:
 
     loadInfo.mCachePromise.swap(cachePromise);
     loadInfo.mCacheStatus = ScriptLoadInfo::WritingToCache;
 
     return NS_OK;
   }
 
   virtual bool
-  Notify(JSContext* aCx, Status aStatus) override
+  Notify(Status aStatus) override
   {
     mWorkerPrivate->AssertIsOnWorkerThread();
 
     if (aStatus >= Terminating && !mCanceled) {
       mCanceled = true;
 
       nsCOMPtr<nsIRunnable> runnable =
         NS_NewRunnableMethod(this,
--- a/dom/workers/ServiceWorkerPrivate.cpp
+++ b/dom/workers/ServiceWorkerPrivate.cpp
@@ -447,17 +447,17 @@ public:
       ReportResult(false);
       return false;
     }
 
     return true;
   }
 
   bool
-  Notify(JSContext* aCx, Status aStatus) override
+  Notify(Status aStatus) override
   {
     if (aStatus < Terminating) {
       return true;
     }
 
     MOZ_ASSERT(GetCurrentThreadWorkerPrivate() == mWorkerPrivate);
     ReportResult(false);
 
--- a/dom/workers/ServiceWorkerRegistration.cpp
+++ b/dom/workers/ServiceWorkerRegistration.cpp
@@ -1139,17 +1139,17 @@ ServiceWorkerRegistrationWorkerThread::R
   } else {
     MOZ_CRASH("Bad reason");
   }
   mListener = nullptr;
   mWorkerPrivate = nullptr;
 }
 
 bool
-ServiceWorkerRegistrationWorkerThread::Notify(JSContext* aCx, workers::Status aStatus)
+ServiceWorkerRegistrationWorkerThread::Notify(workers::Status aStatus)
 {
   ReleaseListener(WorkerIsGoingAway);
   return true;
 }
 
 class FireUpdateFoundRunnable final : public WorkerRunnable
 {
   RefPtr<WorkerListener> mListener;
--- a/dom/workers/ServiceWorkerRegistration.h
+++ b/dom/workers/ServiceWorkerRegistration.h
@@ -234,17 +234,17 @@ public:
 
   void
   GetScope(nsAString& aScope) const
   {
     aScope = mScope;
   }
 
   bool
-  Notify(JSContext* aCx, workers::Status aStatus) override;
+  Notify(workers::Status aStatus) override;
 
   already_AddRefed<WorkerPushManager>
   GetPushManager(ErrorResult& aRv);
 
 private:
   enum Reason
   {
     RegistrationIsGoingAway = 0,
--- a/dom/workers/WorkerFeature.h
+++ b/dom/workers/WorkerFeature.h
@@ -69,14 +69,14 @@ enum Status
   Dead
 };
 
 class WorkerFeature
 {
 public:
   virtual ~WorkerFeature() { }
 
-  virtual bool Notify(JSContext* aCx, Status aStatus) = 0;
+  virtual bool Notify(Status aStatus) = 0;
 };
 
 END_WORKERS_NAMESPACE
 
 #endif /* mozilla_dom_workers_workerfeature_h__ */
--- a/dom/workers/WorkerPrivate.cpp
+++ b/dom/workers/WorkerPrivate.cpp
@@ -5198,17 +5198,17 @@ WorkerPrivate::NotifyFeatures(JSContext*
 
   if (aStatus >= Closing) {
     CancelAllTimeouts();
   }
 
   nsTObserverArray<WorkerFeature*>::ForwardIterator iter(mFeatures);
   while (iter.HasMore()) {
     WorkerFeature* feature = iter.GetNext();
-    if (!feature->Notify(aCx, aStatus)) {
+    if (!feature->Notify(aStatus)) {
       NS_WARNING("Failed to notify feature!");
     }
     MOZ_ASSERT(!JS_IsExceptionPending(aCx));
   }
 
   AutoTArray<ParentType*, 10> children;
   children.AppendElements(mChildWorkers);
 
--- a/dom/workers/XMLHttpRequest.cpp
+++ b/dom/workers/XMLHttpRequest.cpp
@@ -1913,20 +1913,19 @@ XMLHttpRequest::SendInternal(SendRunnabl
   // for it will come from ProxyCompleteRunnable and that always passes true for
   // the second arg.
   if (!autoSyncLoop->Run() && !aRv.Failed()) {
     aRv.Throw(NS_ERROR_FAILURE);
   }
 }
 
 bool
-XMLHttpRequest::Notify(JSContext* aCx, Status aStatus)
+XMLHttpRequest::Notify(Status aStatus)
 {
   mWorkerPrivate->AssertIsOnWorkerThread();
-  MOZ_ASSERT(mWorkerPrivate->GetJSContext() == aCx);
 
   if (aStatus >= Canceling && !mCanceled) {
     mCanceled = true;
     ReleaseProxy(WorkerIsGoingAway);
   }
 
   return true;
 }
--- a/dom/workers/XMLHttpRequest.h
+++ b/dom/workers/XMLHttpRequest.h
@@ -104,17 +104,17 @@ public:
 
     return Constructor(aGlobal, params, aRv);
   }
 
   void
   Unpin();
 
   bool
-  Notify(JSContext* aCx, Status aStatus) override;
+  Notify(Status aStatus) override;
 
   IMPL_EVENT_HANDLER(readystatechange)
 
   uint16_t
   ReadyState() const
   {
     return mStateData.mReadyState;
   }