LCOV - code coverage report
Current view: top level - dom/xhr - XMLHttpRequestWorker.h (source / functions) Hit Total Coverage
Test: output.info Lines: 16 68 23.5 %
Date: 2017-07-14 16:53:18 Functions: 8 31 25.8 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
       2             : /* vim: set ts=8 sts=2 et sw=2 tw=80: */
       3             : /* This Source Code Form is subject to the terms of the Mozilla Public
       4             :  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
       5             :  * You can obtain one at http://mozilla.org/MPL/2.0/. */
       6             : 
       7             : #ifndef mozilla_dom_XMLHttpRequestWorker_h
       8             : #define mozilla_dom_XMLHttpRequestWorker_h
       9             : 
      10             : #include "WorkerHolder.h"
      11             : #include "XMLHttpRequest.h"
      12             : #include "XMLHttpRequestString.h"
      13             : #include "mozilla/dom/TypedArray.h"
      14             : 
      15             : namespace mozilla {
      16             : namespace dom {
      17             : 
      18             : class Proxy;
      19             : class SendRunnable;
      20             : class DOMString;
      21             : 
      22             : namespace workers {
      23             : class WorkerPrivate;
      24             : }
      25             : 
      26             : class XMLHttpRequestWorker final : public XMLHttpRequest,
      27             :                                    public workers::WorkerHolder
      28             : {
      29             : public:
      30          34 :   struct StateData
      31             :   {
      32             :     XMLHttpRequestStringSnapshot mResponseText;
      33             :     nsString mResponseURL;
      34             :     uint32_t mStatus;
      35             :     nsCString mStatusText;
      36             :     uint16_t mReadyState;
      37             :     bool mFlagSend;
      38             :     JS::Heap<JS::Value> mResponse;
      39             :     nsresult mResponseTextResult;
      40             :     nsresult mStatusResult;
      41             :     nsresult mResponseResult;
      42             : 
      43          20 :     StateData()
      44          20 :     : mStatus(0), mReadyState(0), mFlagSend(false),
      45          40 :       mResponse(JS::UndefinedValue()), mResponseTextResult(NS_OK),
      46          60 :       mStatusResult(NS_OK), mResponseResult(NS_OK)
      47          20 :     { }
      48             : 
      49             :     void trace(JSTracer* trc);
      50             :   };
      51             : 
      52             : private:
      53             :   RefPtr<XMLHttpRequestUpload> mUpload;
      54             :   workers::WorkerPrivate* mWorkerPrivate;
      55             :   RefPtr<Proxy> mProxy;
      56             :   XMLHttpRequestResponseType mResponseType;
      57             :   StateData mStateData;
      58             : 
      59             :   uint32_t mTimeout;
      60             : 
      61             :   bool mRooted;
      62             :   bool mBackgroundRequest;
      63             :   bool mWithCredentials;
      64             :   bool mCanceled;
      65             : 
      66             :   bool mMozAnon;
      67             :   bool mMozSystem;
      68             : 
      69             : public:
      70             :   NS_DECL_ISUPPORTS_INHERITED
      71          96 :   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(XMLHttpRequestWorker,
      72             :                                                          XMLHttpRequest)
      73             : 
      74             : 
      75             :   static already_AddRefed<XMLHttpRequest>
      76             :   Construct(const GlobalObject& aGlobal,
      77             :             const MozXMLHttpRequestParameters& aParams,
      78             :             ErrorResult& aRv);
      79             : 
      80             :   void
      81             :   Unpin();
      82             : 
      83             :   bool
      84             :   Notify(workers::Status aStatus) override;
      85             : 
      86             :   virtual uint16_t
      87           0 :   ReadyState() const override
      88             :   {
      89           0 :     return mStateData.mReadyState;
      90             :   }
      91             : 
      92             :   virtual void
      93           0 :   Open(const nsACString& aMethod, const nsAString& aUrl,
      94             :        ErrorResult& aRv) override
      95             :   {
      96           0 :     Open(aMethod, aUrl, true, Optional<nsAString>(),
      97           0 :          Optional<nsAString>(), aRv);
      98           0 :   }
      99             : 
     100             :   virtual void
     101           3 :   Open(const nsACString& aMethod, const nsAString& aUrl, bool aAsync,
     102             :        const nsAString& aUsername, const nsAString& aPassword,
     103             :        ErrorResult& aRv) override
     104             :   {
     105           3 :     Optional<nsAString> username;
     106           3 :     username = &aUsername;
     107           3 :     Optional<nsAString> password;
     108           3 :     password = &aPassword;
     109           3 :     Open(aMethod, aUrl, aAsync, username, password, aRv);
     110           3 :   }
     111             : 
     112             :   void
     113             :   Open(const nsACString& aMethod, const nsAString& aUrl,
     114             :        bool aAsync, const Optional<nsAString>& aUser,
     115             :        const Optional<nsAString>& aPassword, ErrorResult& aRv);
     116             : 
     117             :   virtual void
     118             :   SetRequestHeader(const nsACString& aHeader, const nsACString& aValue,
     119             :                    ErrorResult& aRv) override;
     120             : 
     121             :   virtual uint32_t
     122           0 :   Timeout() const override
     123             :   {
     124           0 :     return mTimeout;
     125             :   }
     126             : 
     127             :   virtual void
     128             :   SetTimeout(uint32_t aTimeout, ErrorResult& aRv) override;
     129             : 
     130             :   virtual bool
     131           0 :   WithCredentials() const override
     132             :   {
     133           0 :     return mWithCredentials;
     134             :   }
     135             : 
     136             :   virtual void
     137             :   SetWithCredentials(bool aWithCredentials, ErrorResult& aRv) override;
     138             : 
     139             :   virtual bool
     140           0 :   MozBackgroundRequest() const override
     141             :   {
     142           0 :     return mBackgroundRequest;
     143             :   }
     144             : 
     145             :   virtual void
     146             :   SetMozBackgroundRequest(bool aBackgroundRequest, ErrorResult& aRv) override;
     147             : 
     148             :   virtual nsIChannel*
     149           0 :   GetChannel() const override
     150             :   {
     151           0 :     MOZ_CRASH("This method cannot be called on workers.");
     152             :   }
     153             : 
     154             :   virtual void
     155           0 :   GetNetworkInterfaceId(nsACString& aId) const override
     156             :   {
     157           0 :     MOZ_CRASH("This method cannot be called on workers.");
     158             :   }
     159             : 
     160             :   virtual void
     161           0 :   SetNetworkInterfaceId(const nsACString& aId) override
     162             :   {
     163           0 :     MOZ_CRASH("This method cannot be called on workers.");
     164             :   }
     165             : 
     166             :   virtual XMLHttpRequestUpload*
     167             :   GetUpload(ErrorResult& aRv) override;
     168             : 
     169             :   virtual void
     170             :   Send(JSContext* aCx, ErrorResult& aRv) override;
     171             : 
     172             :   virtual void
     173             :   Send(JSContext* aCx, const nsAString& aBody, ErrorResult& aRv) override;
     174             : 
     175             :   virtual void
     176           0 :   Send(JSContext* aCx, nsIInputStream* aStream, ErrorResult& aRv) override
     177             :   {
     178           0 :     MOZ_CRASH("This method cannot be called on workers.");
     179             :   }
     180             : 
     181             :   virtual void
     182             :   Send(JSContext* aCx, Blob& aBody, ErrorResult& aRv) override;
     183             : 
     184             :   virtual void
     185             :   Send(JSContext* aCx, FormData& aBody, ErrorResult& aRv) override;
     186             : 
     187             :   virtual void
     188             :   Send(JSContext* aCx, const ArrayBuffer& aBody, ErrorResult& aRv) override;
     189             : 
     190             :   virtual void
     191             :   Send(JSContext* aCx, const ArrayBufferView& aBody, ErrorResult& aRv) override;
     192             : 
     193             :   virtual void
     194             :   Send(JSContext* aCx, URLSearchParams& aBody, ErrorResult& aRv) override;
     195             : 
     196             :   virtual void
     197           0 :   Send(JSContext* aCx, nsIDocument& aDoc, ErrorResult& aRv) override
     198             :   {
     199           0 :     MOZ_CRASH("This method cannot be called on workers.");
     200             :   }
     201             : 
     202             :   virtual void
     203             :   Abort(ErrorResult& aRv) override;
     204             : 
     205             :   virtual void
     206           0 :   GetResponseURL(nsAString& aUrl) override
     207             :   {
     208           0 :     aUrl = mStateData.mResponseURL;
     209           0 :   }
     210             : 
     211             :   uint32_t
     212           0 :   GetStatus(ErrorResult& aRv) override
     213             :   {
     214           0 :     aRv = mStateData.mStatusResult;
     215           0 :     return mStateData.mStatus;
     216             :   }
     217             : 
     218             :   virtual void
     219           0 :   GetStatusText(nsACString& aStatusText, ErrorResult& aRv) override
     220             :   {
     221           0 :     aStatusText = mStateData.mStatusText;
     222           0 :   }
     223             : 
     224             :   virtual void
     225             :   GetResponseHeader(const nsACString& aHeader, nsACString& aResponseHeader,
     226             :                     ErrorResult& aRv) override;
     227             : 
     228             :   virtual void
     229             :   GetAllResponseHeaders(nsACString& aResponseHeaders,
     230             :                         ErrorResult& aRv) override;
     231             : 
     232             :   virtual void
     233             :   OverrideMimeType(const nsAString& aMimeType, ErrorResult& aRv) override;
     234             : 
     235             :   virtual XMLHttpRequestResponseType
     236           0 :   ResponseType() const override
     237             :   {
     238           0 :     return mResponseType;
     239             :   }
     240             : 
     241             :   virtual void
     242             :   SetResponseType(XMLHttpRequestResponseType aResponseType,
     243             :                   ErrorResult& aRv) override;
     244             : 
     245             :   virtual void
     246             :   GetResponse(JSContext* /* unused */, JS::MutableHandle<JS::Value> aResponse,
     247             :               ErrorResult& aRv) override;
     248             : 
     249             :   virtual void
     250             :   GetResponseText(DOMString& aResponseText, ErrorResult& aRv) override;
     251             : 
     252             :   virtual nsIDocument*
     253           0 :   GetResponseXML(ErrorResult& aRv) override
     254             :   {
     255           0 :     MOZ_CRASH("This method should not be called.");
     256             :   }
     257             : 
     258             :   virtual void
     259           0 :   GetInterface(JSContext* aCx, nsIJSID* aIID,
     260             :                JS::MutableHandle<JS::Value> aRetval,
     261             :                ErrorResult& aRv) override
     262             :   {
     263           0 :     aRv.Throw(NS_ERROR_FAILURE);
     264           0 :   }
     265             : 
     266             :   virtual void
     267           0 :   SetOriginAttributes(const mozilla::dom::OriginAttributesDictionary& aAttrs) override
     268             :   {
     269           0 :     MOZ_CRASH("This method cannot be called on workers.");
     270             :   }
     271             : 
     272             :   XMLHttpRequestUpload*
     273           0 :   GetUploadObjectNoCreate() const
     274             :   {
     275           0 :     return mUpload;
     276             :   }
     277             : 
     278             :   void
     279             :   UpdateState(const StateData& aStateData, bool aUseCachedArrayBufferResponse);
     280             : 
     281             :   void
     282           0 :   NullResponseText()
     283             :   {
     284           0 :     mStateData.mResponseText.SetVoid();
     285           0 :     mStateData.mResponse.setNull();
     286           0 :   }
     287             : 
     288           0 :   virtual uint16_t ErrorCode() const override
     289             :   {
     290           0 :     return 0; // eOK
     291             :   }
     292             : 
     293           0 :   virtual bool MozAnon() const override
     294             :   {
     295           0 :     return mMozAnon;
     296             :   }
     297             : 
     298           0 :   virtual bool MozSystem() const override
     299             :   {
     300           0 :     return mMozSystem;
     301             :   }
     302             : 
     303             :   bool
     304           5 :   SendInProgress() const
     305             :   {
     306           5 :     return mRooted;
     307             :   }
     308             : 
     309             : private:
     310             :   explicit XMLHttpRequestWorker(workers::WorkerPrivate* aWorkerPrivate);
     311             :   ~XMLHttpRequestWorker();
     312             : 
     313             :   enum ReleaseType { Default, XHRIsGoingAway, WorkerIsGoingAway };
     314             : 
     315             :   void
     316             :   ReleaseProxy(ReleaseType aType = Default);
     317             : 
     318             :   void
     319             :   MaybePin(ErrorResult& aRv);
     320             : 
     321             :   void
     322             :   MaybeDispatchPrematureAbortEvents(ErrorResult& aRv);
     323             : 
     324             :   void
     325             :   DispatchPrematureAbortEvent(EventTarget* aTarget,
     326             :                               const nsAString& aEventType, bool aUploadTarget,
     327             :                               ErrorResult& aRv);
     328             : 
     329             :   void
     330             :   Send(JSContext* aCx, JS::Handle<JSObject*> aBody, ErrorResult& aRv);
     331             : 
     332             :   void
     333             :   SendInternal(SendRunnable* aRunnable,
     334             :                ErrorResult& aRv);
     335             : };
     336             : 
     337             : } // dom namespace
     338             : } // mozilla namespace
     339             : 
     340             : #endif // mozilla_dom_workers_xmlhttprequest_h__

Generated by: LCOV version 1.13