LCOV - app.info - netwerk/protocol/wyciwyg/WyciwygChannelChild.cpp

LCOV - code coverage report
| Current view: | directory - netwerk/protocol/wyciwyg - WyciwygChannelChild.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 265 | 0 | 0.0 %
| Date: | 2012-07-07 | Functions: | 67 | 0 | 0.0 %

           1                 : /* ***** BEGIN LICENSE BLOCK *****
           2                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
           3                 :  *
           4                 :  * The contents of this file are subject to the Mozilla Public License Version
           5                 :  * 1.1 (the "License"); you may not use this file except in compliance with
           6                 :  * the License. You may obtain a copy of the License at
           7                 :  * http://www.mozilla.org/MPL/
           8                 :  *
           9                 :  * Software distributed under the License is distributed on an "AS IS" basis,
          10                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
          11                 :  * for the specific language governing rights and limitations under the
          12                 :  * License.
          13                 :  *
          14                 :  * The Original Code is mozilla.org code.
          15                 :  *
          16                 :  * The Initial Developer of the Original Code is
          17                 :  *  The Mozilla Foundation
          18                 :  * Portions created by the Initial Developer are Copyright (C) 2010
          19                 :  * the Initial Developer. All Rights Reserved.
          20                 :  *
          21                 :  * Contributor(s):
          22                 :  *   Michal Novotny <michal.novotny@gmail.com>
          23                 :  *
          24                 :  * Alternatively, the contents of this file may be used under the terms of
          25                 :  * either the GNU General Public License Version 2 or later (the "GPL"), or
          26                 :  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          27                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          28                 :  * of those above. If you wish to allow use of your version of this file only
          29                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          30                 :  * use your version of this file under the terms of the MPL, indicate your
          31                 :  * decision by deleting the provisions above and replace them with the notice
          32                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          33                 :  * the provisions above, a recipient may use your version of this file under
          34                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          35                 :  *
          36                 :  * ***** END LICENSE BLOCK ***** */
          37                 :
          38                 : #include "nsWyciwyg.h"
          39                 :
          40                 : #include "mozilla/net/NeckoChild.h"
          41                 : #include "WyciwygChannelChild.h"
          42                 :
          43                 : #include "nsIParser.h"
          44                 : #include "nsStringStream.h"
          45                 : #include "nsMimeTypes.h"
          46                 : #include "nsNetUtil.h"
          47                 : #include "nsISerializable.h"
          48                 : #include "nsSerializationHelper.h"
          49                 :
          50                 : namespace mozilla {
          51                 : namespace net {
          52                 :
          53               0 : NS_IMPL_ISUPPORTS3(WyciwygChannelChild,
          54                 :                    nsIRequest,
          55                 :                    nsIChannel,
          56                 :                    nsIWyciwygChannel);
          57                 :
          58                 :
          59               0 : WyciwygChannelChild::WyciwygChannelChild()
          60                 :   : mStatus(NS_OK)
          61                 :   , mIsPending(false)
          62                 :   , mCanceled(false)
          63                 :   , mLoadFlags(LOAD_NORMAL)
          64                 :   , mContentLength(-1)
          65                 :   , mCharsetSource(kCharsetUninitialized)
          66                 :   , mState(WCC_NEW)
          67                 :   , mIPCOpen(false)
          68               0 :   , mEventQ(this)
          69                 : {
          70               0 :   LOG(("Creating WyciwygChannelChild @%x\n", this));
          71               0 : }
          72                 :
          73               0 : WyciwygChannelChild::~WyciwygChannelChild()
          74                 : {
          75               0 :   LOG(("Destroying WyciwygChannelChild @%x\n", this));
          76               0 : }
          77                 :
          78                 : void
          79               0 : WyciwygChannelChild::AddIPDLReference()
          80                 : {
          81               0 :   NS_ABORT_IF_FALSE(!mIPCOpen, "Attempt to retain more than one IPDL reference");
          82               0 :   mIPCOpen = true;
          83               0 :   AddRef();
          84               0 : }
          85                 :
          86                 : void
          87               0 : WyciwygChannelChild::ReleaseIPDLReference()
          88                 : {
          89               0 :   NS_ABORT_IF_FALSE(mIPCOpen, "Attempt to release nonexistent IPDL reference");
          90               0 :   mIPCOpen = false;
          91               0 :   Release();
          92               0 : }
          93                 :
          94                 : nsresult
          95               0 : WyciwygChannelChild::Init(nsIURI* uri)
          96                 : {
          97               0 :   NS_ENSURE_ARG_POINTER(uri);
          98                 :
          99               0 :   mState = WCC_INIT;
         100                 :
         101               0 :   mURI = uri;
         102               0 :   mOriginalURI = uri;
         103                 :
         104               0 :   SendInit(IPC::URI(mURI));
         105               0 :   return NS_OK;
         106                 : }
         107                 :
         108                 : //-----------------------------------------------------------------------------
         109                 : // WyciwygChannelChild::PWyciwygChannelChild
         110                 : //-----------------------------------------------------------------------------
         111                 :
         112                 : class WyciwygStartRequestEvent : public ChannelEvent
         113               0 : {
         114                 : public:
         115               0 :   WyciwygStartRequestEvent(WyciwygChannelChild* child,
         116                 :                            const nsresult& statusCode,
         117                 :                            const PRInt32& contentLength,
         118                 :                            const PRInt32& source,
         119                 :                            const nsCString& charset,
         120                 :                            const nsCString& securityInfo)
         121                 :   : mChild(child), mStatusCode(statusCode), mContentLength(contentLength),
         122               0 :     mSource(source), mCharset(charset), mSecurityInfo(securityInfo) {}
         123               0 :   void Run() { mChild->OnStartRequest(mStatusCode, mContentLength, mSource,
         124               0 :                                      mCharset, mSecurityInfo); }
         125                 : private:
         126                 :   WyciwygChannelChild* mChild;
         127                 :   nsresult mStatusCode;
         128                 :   PRInt32 mContentLength;
         129                 :   PRInt32 mSource;
         130                 :   nsCString mCharset;
         131                 :   nsCString mSecurityInfo;
         132                 : };
         133                 :
         134                 : bool
         135               0 : WyciwygChannelChild::RecvOnStartRequest(const nsresult& statusCode,
         136                 :                                         const PRInt32& contentLength,
         137                 :                                         const PRInt32& source,
         138                 :                                         const nsCString& charset,
         139                 :                                         const nsCString& securityInfo)
         140                 : {
         141               0 :   if (mEventQ.ShouldEnqueue()) {
         142                 :     mEventQ.Enqueue(new WyciwygStartRequestEvent(this, statusCode,
         143                 :                                                  contentLength, source,
         144               0 :                                                  charset, securityInfo));
         145                 :   } else {
         146               0 :     OnStartRequest(statusCode, contentLength, source, charset, securityInfo);
         147                 :   }
         148               0 :   return true;
         149                 : }
         150                 :
         151                 : void
         152               0 : WyciwygChannelChild::OnStartRequest(const nsresult& statusCode,
         153                 :                                     const PRInt32& contentLength,
         154                 :                                     const PRInt32& source,
         155                 :                                     const nsCString& charset,
         156                 :                                     const nsCString& securityInfo)
         157                 : {
         158               0 :   LOG(("WyciwygChannelChild::RecvOnStartRequest [this=%x]\n", this));
         159                 :
         160               0 :   mState = WCC_ONSTART;
         161                 :
         162               0 :   mStatus = statusCode;
         163               0 :   mContentLength = contentLength;
         164               0 :   mCharsetSource = source;
         165               0 :   mCharset = charset;
         166                 :
         167               0 :   if (!securityInfo.IsEmpty()) {
         168               0 :     NS_DeserializeObject(securityInfo, getter_AddRefs(mSecurityInfo));
         169                 :   }
         170                 :
         171               0 :   AutoEventEnqueuer ensureSerialDispatch(mEventQ);
         172                 :
         173               0 :   nsresult rv = mListener->OnStartRequest(this, mListenerContext);
         174               0 :   if (NS_FAILED(rv))
         175               0 :     Cancel(rv);
         176               0 : }
         177                 :
         178                 : class WyciwygDataAvailableEvent : public ChannelEvent
         179               0 : {
         180                 : public:
         181               0 :   WyciwygDataAvailableEvent(WyciwygChannelChild* child,
         182                 :                             const nsCString& data,
         183                 :                             const PRUint32& offset)
         184               0 :   : mChild(child), mData(data), mOffset(offset) {}
         185               0 :   void Run() { mChild->OnDataAvailable(mData, mOffset); }
         186                 : private:
         187                 :   WyciwygChannelChild* mChild;
         188                 :   nsCString mData;
         189                 :   PRUint32 mOffset;
         190                 : };
         191                 :
         192                 : bool
         193               0 : WyciwygChannelChild::RecvOnDataAvailable(const nsCString& data,
         194                 :                                          const PRUint32& offset)
         195                 : {
         196               0 :   if (mEventQ.ShouldEnqueue()) {
         197               0 :     mEventQ.Enqueue(new WyciwygDataAvailableEvent(this, data, offset));
         198                 :   } else {
         199               0 :     OnDataAvailable(data, offset);
         200                 :   }
         201               0 :   return true;
         202                 : }
         203                 :
         204                 : void
         205               0 : WyciwygChannelChild::OnDataAvailable(const nsCString& data,
         206                 :                                      const PRUint32& offset)
         207                 : {
         208               0 :   LOG(("WyciwygChannelChild::RecvOnDataAvailable [this=%x]\n", this));
         209                 :
         210               0 :   if (mCanceled)
         211               0 :     return;
         212                 :
         213               0 :   mState = WCC_ONDATA;
         214                 :
         215                 :   // NOTE: the OnDataAvailable contract requires the client to read all the data
         216                 :   // in the inputstream.  This code relies on that ('data' will go away after
         217                 :   // this function).  Apparently the previous, non-e10s behavior was to actually
         218                 :   // support only reading part of the data, allowing later calls to read the
         219                 :   // rest.
         220               0 :   nsCOMPtr<nsIInputStream> stringStream;
         221               0 :   nsresult rv = NS_NewByteInputStream(getter_AddRefs(stringStream),
         222                 :                                       data.get(),
         223               0 :                                       data.Length(),
         224               0 :                                       NS_ASSIGNMENT_DEPEND);
         225               0 :   if (NS_FAILED(rv)) {
         226               0 :     Cancel(rv);
         227                 :     return;
         228                 :   }
         229                 :
         230               0 :   AutoEventEnqueuer ensureSerialDispatch(mEventQ);
         231                 :
         232               0 :   rv = mListener->OnDataAvailable(this, mListenerContext,
         233               0 :                                   stringStream, offset, data.Length());
         234               0 :   if (NS_FAILED(rv))
         235               0 :     Cancel(rv);
         236                 :
         237               0 :   if (mProgressSink && NS_SUCCEEDED(rv) && !(mLoadFlags & LOAD_BACKGROUND))
         238               0 :     mProgressSink->OnProgress(this, nsnull, PRUint64(offset + data.Length()),
         239               0 :                               PRUint64(mContentLength));
         240                 : }
         241                 :
         242                 : class WyciwygStopRequestEvent : public ChannelEvent
         243               0 : {
         244                 : public:
         245               0 :   WyciwygStopRequestEvent(WyciwygChannelChild* child,
         246                 :                           const nsresult& statusCode)
         247               0 :   : mChild(child), mStatusCode(statusCode) {}
         248               0 :   void Run() { mChild->OnStopRequest(mStatusCode); }
         249                 : private:
         250                 :   WyciwygChannelChild* mChild;
         251                 :   nsresult mStatusCode;
         252                 : };
         253                 :
         254                 : bool
         255               0 : WyciwygChannelChild::RecvOnStopRequest(const nsresult& statusCode)
         256                 : {
         257               0 :   if (mEventQ.ShouldEnqueue()) {
         258               0 :     mEventQ.Enqueue(new WyciwygStopRequestEvent(this, statusCode));
         259                 :   } else {
         260               0 :     OnStopRequest(statusCode);
         261                 :   }
         262               0 :   return true;
         263                 : }
         264                 :
         265                 : void
         266               0 : WyciwygChannelChild::OnStopRequest(const nsresult& statusCode)
         267                 : {
         268               0 :   LOG(("WyciwygChannelChild::RecvOnStopRequest [this=%x status=%u]\n",
         269                 :            this, statusCode));
         270                 :
         271                 :   { // We need to ensure that all IPDL message dispatching occurs
         272                 :     // before we delete the protocol below
         273               0 :     AutoEventEnqueuer ensureSerialDispatch(mEventQ);
         274                 :
         275               0 :     mState = WCC_ONSTOP;
         276                 :
         277               0 :     mIsPending = false;
         278                 :
         279               0 :     if (!mCanceled)
         280               0 :       mStatus = statusCode;
         281                 :
         282               0 :     mListener->OnStopRequest(this, mListenerContext, statusCode);
         283                 :
         284               0 :     mListener = 0;
         285               0 :     mListenerContext = 0;
         286                 :
         287               0 :     if (mLoadGroup)
         288               0 :       mLoadGroup->RemoveRequest(this, nsnull, mStatus);
         289                 :
         290               0 :     mCallbacks = 0;
         291               0 :     mProgressSink = 0;
         292                 :   }
         293                 :
         294               0 :   if (mIPCOpen)
         295               0 :     PWyciwygChannelChild::Send__delete__(this);
         296               0 : }
         297                 :
         298                 : class WyciwygCancelEvent : public ChannelEvent
         299               0 : {
         300                 :  public:
         301               0 :   WyciwygCancelEvent(WyciwygChannelChild* child, const nsresult& status)
         302                 :   : mChild(child)
         303               0 :   , mStatus(status) {}
         304                 :
         305               0 :   void Run() { mChild->CancelEarly(mStatus); }
         306                 :  private:
         307                 :   WyciwygChannelChild* mChild;
         308                 :   nsresult mStatus;
         309                 : };
         310                 :
         311                 : bool
         312               0 : WyciwygChannelChild::RecvCancelEarly(const nsresult& statusCode)
         313                 : {
         314               0 :   if (mEventQ.ShouldEnqueue()) {
         315               0 :     mEventQ.Enqueue(new WyciwygCancelEvent(this, statusCode));
         316                 :   } else {
         317               0 :     CancelEarly(statusCode);
         318                 :   }
         319               0 :   return true;
         320                 : }
         321                 :
         322               0 : void WyciwygChannelChild::CancelEarly(const nsresult& statusCode)
         323                 : {
         324               0 :   LOG(("WyciwygChannelChild::CancelEarly [this=%x]\n", this));
         325                 :
         326               0 :   if (mCanceled)
         327               0 :     return;
         328                 :
         329               0 :   mCanceled = true;
         330               0 :   mStatus = statusCode;
         331                 :
         332               0 :   mIsPending = false;
         333               0 :   if (mLoadGroup)
         334               0 :     mLoadGroup->RemoveRequest(this, nsnull, mStatus);
         335                 :
         336               0 :   if (mListener) {
         337               0 :     mListener->OnStartRequest(this, mListenerContext);
         338               0 :     mListener->OnStopRequest(this, mListenerContext, mStatus);
         339                 :   }
         340               0 :   mListener = nsnull;
         341               0 :   mListenerContext = nsnull;
         342                 :
         343               0 :   if (mIPCOpen)
         344               0 :     PWyciwygChannelChild::Send__delete__(this);
         345                 : }
         346                 :
         347                 : //-----------------------------------------------------------------------------
         348                 : // nsIRequest
         349                 : //-----------------------------------------------------------------------------
         350                 :
         351                 : /* readonly attribute AUTF8String name; */
         352                 : NS_IMETHODIMP
         353               0 : WyciwygChannelChild::GetName(nsACString & aName)
         354                 : {
         355               0 :   return mURI->GetSpec(aName);
         356                 : }
         357                 :
         358                 : /* boolean isPending (); */
         359                 : NS_IMETHODIMP
         360               0 : WyciwygChannelChild::IsPending(bool *aIsPending)
         361                 : {
         362               0 :   *aIsPending = mIsPending;
         363               0 :   return NS_OK;
         364                 : }
         365                 :
         366                 : /* readonly attribute nsresult status; */
         367                 : NS_IMETHODIMP
         368               0 : WyciwygChannelChild::GetStatus(nsresult *aStatus)
         369                 : {
         370               0 :   *aStatus = mStatus;
         371               0 :   return NS_OK;
         372                 : }
         373                 :
         374                 : /* void cancel (in nsresult aStatus); */
         375                 : NS_IMETHODIMP
         376               0 : WyciwygChannelChild::Cancel(nsresult aStatus)
         377                 : {
         378               0 :   if (mCanceled)
         379               0 :     return NS_OK;
         380                 :
         381               0 :   mCanceled = true;
         382               0 :   mStatus = aStatus;
         383               0 :   if (mIPCOpen)
         384               0 :     SendCancel(aStatus);
         385               0 :   return NS_OK;
         386                 : }
         387                 :
         388                 : /* void suspend (); */
         389                 : NS_IMETHODIMP
         390               0 : WyciwygChannelChild::Suspend()
         391                 : {
         392               0 :   return NS_ERROR_NOT_IMPLEMENTED;
         393                 : }
         394                 :
         395                 : /* void resume (); */
         396                 : NS_IMETHODIMP
         397               0 : WyciwygChannelChild::Resume()
         398                 : {
         399               0 :   return NS_ERROR_NOT_IMPLEMENTED;
         400                 : }
         401                 :
         402                 : /* attribute nsILoadGroup loadGroup; */
         403                 : NS_IMETHODIMP
         404               0 : WyciwygChannelChild::GetLoadGroup(nsILoadGroup * *aLoadGroup)
         405                 : {
         406               0 :   *aLoadGroup = mLoadGroup;
         407               0 :   NS_IF_ADDREF(*aLoadGroup);
         408               0 :   return NS_OK;
         409                 : }
         410                 : NS_IMETHODIMP
         411               0 : WyciwygChannelChild::SetLoadGroup(nsILoadGroup * aLoadGroup)
         412                 : {
         413               0 :   mLoadGroup = aLoadGroup;
         414                 :   NS_QueryNotificationCallbacks(mCallbacks,
         415                 :                                 mLoadGroup,
         416                 :                                 NS_GET_IID(nsIProgressEventSink),
         417               0 :                                 getter_AddRefs(mProgressSink));
         418               0 :   return NS_OK;
         419                 : }
         420                 :
         421                 : /* attribute nsLoadFlags loadFlags; */
         422                 : NS_IMETHODIMP
         423               0 : WyciwygChannelChild::GetLoadFlags(nsLoadFlags *aLoadFlags)
         424                 : {
         425               0 :   *aLoadFlags = mLoadFlags;
         426               0 :   return NS_OK;
         427                 : }
         428                 : NS_IMETHODIMP
         429               0 : WyciwygChannelChild::SetLoadFlags(nsLoadFlags aLoadFlags)
         430                 : {
         431               0 :   mLoadFlags = aLoadFlags;
         432               0 :   return NS_OK;
         433                 : }
         434                 :
         435                 :
         436                 : //-----------------------------------------------------------------------------
         437                 : // nsIChannel
         438                 : //-----------------------------------------------------------------------------
         439                 :
         440                 : /* attribute nsIURI originalURI; */
         441                 : NS_IMETHODIMP
         442               0 : WyciwygChannelChild::GetOriginalURI(nsIURI * *aOriginalURI)
         443                 : {
         444               0 :   *aOriginalURI = mOriginalURI;
         445               0 :   NS_ADDREF(*aOriginalURI);
         446               0 :   return NS_OK;
         447                 : }
         448                 : NS_IMETHODIMP
         449               0 : WyciwygChannelChild::SetOriginalURI(nsIURI * aOriginalURI)
         450                 : {
         451               0 :   NS_ENSURE_TRUE(mState == WCC_INIT, NS_ERROR_UNEXPECTED);
         452                 :
         453               0 :   NS_ENSURE_ARG_POINTER(aOriginalURI);
         454               0 :   mOriginalURI = aOriginalURI;
         455               0 :   return NS_OK;
         456                 : }
         457                 :
         458                 : /* readonly attribute nsIURI URI; */
         459                 : NS_IMETHODIMP
         460               0 : WyciwygChannelChild::GetURI(nsIURI * *aURI)
         461                 : {
         462               0 :   *aURI = mURI;
         463               0 :   NS_IF_ADDREF(*aURI);
         464               0 :   return NS_OK;
         465                 : }
         466                 :
         467                 : /* attribute nsISupports owner; */
         468                 : NS_IMETHODIMP
         469               0 : WyciwygChannelChild::GetOwner(nsISupports * *aOwner)
         470                 : {
         471               0 :   NS_PRECONDITION(mOwner, "Must have a principal!");
         472               0 :   NS_ENSURE_STATE(mOwner);
         473                 :
         474               0 :   NS_ADDREF(*aOwner = mOwner);
         475               0 :   return NS_OK;
         476                 : }
         477                 : NS_IMETHODIMP
         478               0 : WyciwygChannelChild::SetOwner(nsISupports * aOwner)
         479                 : {
         480               0 :   mOwner = aOwner;
         481               0 :   return NS_OK;
         482                 : }
         483                 :
         484                 : /* attribute nsIInterfaceRequestor notificationCallbacks; */
         485                 : NS_IMETHODIMP
         486               0 : WyciwygChannelChild::GetNotificationCallbacks(nsIInterfaceRequestor * *aCallbacks)
         487                 : {
         488               0 :   *aCallbacks = mCallbacks;
         489               0 :   NS_IF_ADDREF(*aCallbacks);
         490               0 :   return NS_OK;
         491                 : }
         492                 : NS_IMETHODIMP
         493               0 : WyciwygChannelChild::SetNotificationCallbacks(nsIInterfaceRequestor * aCallbacks)
         494                 : {
         495               0 :   mCallbacks = aCallbacks;
         496                 :   NS_QueryNotificationCallbacks(mCallbacks,
         497                 :                                 mLoadGroup,
         498                 :                                 NS_GET_IID(nsIProgressEventSink),
         499               0 :                                 getter_AddRefs(mProgressSink));
         500               0 :   return NS_OK;
         501                 : }
         502                 :
         503                 : /* readonly attribute nsISupports securityInfo; */
         504                 : NS_IMETHODIMP
         505               0 : WyciwygChannelChild::GetSecurityInfo(nsISupports * *aSecurityInfo)
         506                 : {
         507               0 :   NS_IF_ADDREF(*aSecurityInfo = mSecurityInfo);
         508                 :
         509               0 :   return NS_OK;
         510                 : }
         511                 :
         512                 : /* attribute ACString contentType; */
         513                 : NS_IMETHODIMP
         514               0 : WyciwygChannelChild::GetContentType(nsACString & aContentType)
         515                 : {
         516               0 :   aContentType.AssignLiteral(WYCIWYG_TYPE);
         517               0 :   return NS_OK;
         518                 : }
         519                 : NS_IMETHODIMP
         520               0 : WyciwygChannelChild::SetContentType(const nsACString & aContentType)
         521                 : {
         522               0 :   return NS_ERROR_NOT_IMPLEMENTED;
         523                 : }
         524                 :
         525                 : /* attribute ACString contentCharset; */
         526                 : NS_IMETHODIMP
         527               0 : WyciwygChannelChild::GetContentCharset(nsACString & aContentCharset)
         528                 : {
         529               0 :   aContentCharset.Assign("UTF-16");
         530               0 :   return NS_OK;
         531                 : }
         532                 : NS_IMETHODIMP
         533               0 : WyciwygChannelChild::SetContentCharset(const nsACString & aContentCharset)
         534                 : {
         535               0 :   return NS_ERROR_NOT_IMPLEMENTED;
         536                 : }
         537                 :
         538                 : NS_IMETHODIMP
         539               0 : WyciwygChannelChild::GetContentDisposition(PRUint32 *aContentDisposition)
         540                 : {
         541               0 :   return NS_ERROR_NOT_AVAILABLE;
         542                 : }
         543                 :
         544                 : NS_IMETHODIMP
         545               0 : WyciwygChannelChild::GetContentDispositionFilename(nsAString &aContentDispositionFilename)
         546                 : {
         547               0 :   return NS_ERROR_NOT_AVAILABLE;
         548                 : }
         549                 :
         550                 : NS_IMETHODIMP
         551               0 : WyciwygChannelChild::GetContentDispositionHeader(nsACString &aContentDispositionHeader)
         552                 : {
         553               0 :   return NS_ERROR_NOT_AVAILABLE;
         554                 : }
         555                 :
         556                 : /* attribute long contentLength; */
         557                 : NS_IMETHODIMP
         558               0 : WyciwygChannelChild::GetContentLength(PRInt32 *aContentLength)
         559                 : {
         560               0 :   return NS_ERROR_NOT_IMPLEMENTED;
         561                 : }
         562                 : NS_IMETHODIMP
         563               0 : WyciwygChannelChild::SetContentLength(PRInt32 aContentLength)
         564                 : {
         565               0 :   return NS_ERROR_NOT_IMPLEMENTED;
         566                 : }
         567                 :
         568                 : /* nsIInputStream open (); */
         569                 : NS_IMETHODIMP
         570               0 : WyciwygChannelChild::Open(nsIInputStream **_retval)
         571                 : {
         572               0 :   return NS_ERROR_NOT_IMPLEMENTED;
         573                 : }
         574                 :
         575                 : /* void asyncOpen (in nsIStreamListener aListener, in nsISupports aContext); */
         576                 : NS_IMETHODIMP
         577               0 : WyciwygChannelChild::AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext)
         578                 : {
         579               0 :   LOG(("WyciwygChannelChild::AsyncOpen [this=%x]\n", this));
         580                 :
         581                 :   // The only places creating wyciwyg: channels should be
         582                 :   // HTMLDocument::OpenCommon and session history.  Both should be setting an
         583                 :   // owner.
         584               0 :   NS_PRECONDITION(mOwner, "Must have a principal");
         585               0 :   NS_ENSURE_STATE(mOwner);
         586                 :
         587               0 :   NS_ENSURE_ARG_POINTER(aListener);
         588               0 :   NS_ENSURE_TRUE(!mIsPending, NS_ERROR_IN_PROGRESS);
         589                 :
         590               0 :   mListener = aListener;
         591               0 :   mListenerContext = aContext;
         592               0 :   mIsPending = true;
         593                 :
         594               0 :   if (mLoadGroup)
         595               0 :     mLoadGroup->AddRequest(this, nsnull);
         596                 :
         597               0 :   SendAsyncOpen(IPC::URI(mOriginalURI), mLoadFlags);
         598                 :
         599               0 :   mState = WCC_OPENED;
         600                 :
         601               0 :   return NS_OK;
         602                 : }
         603                 :
         604                 :
         605                 : //-----------------------------------------------------------------------------
         606                 : // nsIWyciwygChannel
         607                 : //-----------------------------------------------------------------------------
         608                 :
         609                 : /* void writeToCacheEntry (in AString aData); */
         610                 : NS_IMETHODIMP
         611               0 : WyciwygChannelChild::WriteToCacheEntry(const nsAString & aData)
         612                 : {
         613               0 :   NS_ENSURE_TRUE((mState == WCC_INIT) ||
         614                 :                  (mState == WCC_ONWRITE), NS_ERROR_UNEXPECTED);
         615                 :
         616               0 :   SendWriteToCacheEntry(PromiseFlatString(aData));
         617               0 :   mState = WCC_ONWRITE;
         618               0 :   return NS_OK;
         619                 : }
         620                 :
         621                 : /* void closeCacheEntry (in nsresult reason); */
         622                 : NS_IMETHODIMP
         623               0 : WyciwygChannelChild::CloseCacheEntry(nsresult reason)
         624                 : {
         625               0 :   NS_ENSURE_TRUE(mState == WCC_ONWRITE, NS_ERROR_UNEXPECTED);
         626                 :
         627               0 :   SendCloseCacheEntry(reason);
         628               0 :   mState = WCC_ONCLOSED;
         629                 :
         630               0 :   if (mIPCOpen)
         631               0 :     PWyciwygChannelChild::Send__delete__(this);
         632                 :
         633               0 :   return NS_OK;
         634                 : }
         635                 :
         636                 : /* void setSecurityInfo (in nsISupports aSecurityInfo); */
         637                 : NS_IMETHODIMP
         638               0 : WyciwygChannelChild::SetSecurityInfo(nsISupports *aSecurityInfo)
         639                 : {
         640               0 :   mSecurityInfo = aSecurityInfo;
         641                 :
         642               0 :   if (mSecurityInfo) {
         643               0 :     nsCOMPtr<nsISerializable> serializable = do_QueryInterface(mSecurityInfo);
         644               0 :     if (serializable) {
         645               0 :       nsCString secInfoStr;
         646               0 :       NS_SerializeToString(serializable, secInfoStr);
         647               0 :       SendSetSecurityInfo(secInfoStr);
         648                 :     }
         649                 :     else {
         650               0 :       NS_WARNING("Can't serialize security info");
         651                 :     }
         652                 :   }
         653                 :
         654               0 :   return NS_OK;
         655                 : }
         656                 :
         657                 : /* void setCharsetAndSource (in long aSource, in ACString aCharset); */
         658                 : NS_IMETHODIMP
         659               0 : WyciwygChannelChild::SetCharsetAndSource(PRInt32 aSource, const nsACString & aCharset)
         660                 : {
         661                 :   // mState == WCC_ONSTART when reading from the channel
         662                 :   // mState == WCC_INIT when writing to the cache
         663               0 :   NS_ENSURE_TRUE((mState == WCC_ONSTART) ||
         664                 :                  (mState == WCC_INIT), NS_ERROR_UNEXPECTED);
         665                 :
         666               0 :   mCharsetSource = aSource;
         667               0 :   mCharset = aCharset;
         668                 :
         669                 :   // TODO ensure that nsWyciwygChannel in the parent has still the cache entry
         670               0 :   SendSetCharsetAndSource(mCharsetSource, mCharset);
         671               0 :   return NS_OK;
         672                 : }
         673                 :
         674                 : /* ACString getCharsetAndSource (out long aSource); */
         675                 : NS_IMETHODIMP
         676               0 : WyciwygChannelChild::GetCharsetAndSource(PRInt32 *aSource NS_OUTPARAM, nsACString & _retval)
         677                 : {
         678               0 :   NS_ENSURE_TRUE((mState == WCC_ONSTART) ||
         679                 :                  (mState == WCC_ONDATA) ||
         680                 :                  (mState == WCC_ONSTOP), NS_ERROR_NOT_AVAILABLE);
         681                 :
         682               0 :   if (mCharsetSource == kCharsetUninitialized)
         683               0 :     return NS_ERROR_NOT_AVAILABLE;
         684                 :
         685               0 :   *aSource = mCharsetSource;
         686               0 :   _retval = mCharset;
         687               0 :   return NS_OK;
         688                 : }
         689                 :
         690                 : //------------------------------------------------------------------------------
         691                 : }} // mozilla::net

Generated by: LCOV version 1.7