modules/libpr0n/src/imgRequestProxy.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  *
   3  * ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is mozilla.org code.
  17  *
  18  * The Initial Developer of the Original Code is
  19  * Netscape Communications Corporation.
  20  * Portions created by the Initial Developer are Copyright (C) 2001
  21  * the Initial Developer. All Rights Reserved.
  22  *
  23  * Contributor(s):
  24  *   Stuart Parmenter <stuart@mozilla.com>
  25  *
  26  * Alternatively, the contents of this file may be used under the terms of
  27  * either the GNU General Public License Version 2 or later (the "GPL"), or
  28  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29  * in which case the provisions of the GPL or the LGPL are applicable instead
  30  * of those above. If you wish to allow use of your version of this file only
  31  * under the terms of either the GPL or the LGPL, and not to allow others to
  32  * use your version of this file under the terms of the MPL, indicate your
  33  * decision by deleting the provisions above and replace them with the notice
  34  * and other provisions required by the GPL or the LGPL. If you do not delete
  35  * the provisions above, a recipient may use your version of this file under
  36  * the terms of any one of the MPL, the GPL or the LGPL.
  37  *
  38  * ***** END LICENSE BLOCK ***** */
  39
  40 #include "imgRequestProxy.h"
  41
  42 #include "nsIInputStream.h"
  43 #include "nsIComponentManager.h"
  44 #include "nsIServiceManager.h"
  45 #include "nsIMultiPartChannel.h"
  46
  47 #include "nsString.h"
  48 #include "nsXPIDLString.h"
  49 #include "nsReadableUtils.h"
  50 #include "nsCRT.h"
  51
  52 #include "ImageErrors.h"
  53 #include "ImageLogging.h"
  54
  55 #include "nspr.h"
  56
  57
  58 NS_IMPL_ISUPPORTS3(imgRequestProxy, imgIRequest, nsIRequest,
  59                    nsISupportsPriority)
  60
  61 imgRequestProxy::imgRequestProxy() :
  62   mOwner(nsnull),
  63   mListener(nsnull),
  64   mLoadFlags(nsIRequest::LOAD_NORMAL),
  65   mCanceled(PR_FALSE),
  66   mIsInLoadGroup(PR_FALSE),
  67   mListenerIsStrongRef(PR_FALSE)
  68 {
  69   /* member initializers and constructor code */
  70
  71 }
  72
  73 imgRequestProxy::~imgRequestProxy()
  74 {
  75   /* destructor code */
  76   NS_PRECONDITION(!mListener, "Someone forgot to properly cancel this request!");
  77   // Explicitly set mListener to null to ensure that the RemoveProxy
  78   // call below can't send |this| to an arbitrary listener while |this|
  79   // is being destroyed.  This is all belt-and-suspenders in view of the
  80   // above assert.
  81   NullOutListener();
  82
  83   if (mOwner) {
  84     if (!mCanceled) {
  85       mCanceled = PR_TRUE;
  86
  87       /* Call RemoveProxy with a successful status.  This will keep the
  88          channel, if still downloading data, from being canceled if 'this' is
  89          the last observer.  This allows the image to continue to download and
  90          be cached even if no one is using it currently.
  91
  92          Passing false to aNotify means that we will still get
  93          OnStopRequest, if needed.
  94        */
  95       mOwner->RemoveProxy(this, NS_OK, PR_FALSE);
  96     }
  97   }
  98 }
  99
 100
 101
 102 nsresult imgRequestProxy::Init(imgRequest *request, nsILoadGroup *aLoadGroup, imgIDecoderObserver *aObserver)
 103 {
 104   NS_PRECONDITION(!mOwner && !mListener, "imgRequestProxy is already initialized");
 105   NS_PRECONDITION(request, "no request");
 106   if (!request)
 107     return NS_ERROR_NULL_POINTER;
 108
 109   LOG_SCOPE_WITH_PARAM(gImgLog, "imgRequestProxy::Init", "request", request);
 110
 111   mOwner = request;
 112   mListener = aObserver;
 113   // Make sure to addref mListener before the AddProxy call below, since
 114   // that call might well want to release it if the imgRequest has
 115   // already seen OnStopRequest.
 116   if (mListener) {
 117     mListenerIsStrongRef = PR_TRUE;
 118     NS_ADDREF(mListener);
 119   }
 120   mLoadGroup = aLoadGroup;
 121
 122   // Note: AddProxy won't send all the On* notifications immediatly
 123   request->AddProxy(this);
 124
 125   return NS_OK;
 126 }
 127
 128 nsresult imgRequestProxy::ChangeOwner(imgRequest *aNewOwner)
 129 {
 130   if (mCanceled)
 131     return NS_OK;
 132
 133   // Passing false to aNotify means that mListener will still get
 134   // OnStopRequest, if needed.
 135   mOwner->RemoveProxy(this, NS_IMAGELIB_CHANGING_OWNER, PR_FALSE);
 136
 137   mOwner = aNewOwner;
 138
 139   mOwner->AddProxy(this);
 140
 141   return NS_OK;
 142 }
 143
 144 void imgRequestProxy::AddToLoadGroup()
 145 {
 146   NS_ASSERTION(!mIsInLoadGroup, "Whaa, we're already in the loadgroup!");
 147
 148   if (!mIsInLoadGroup && mLoadGroup) {
 149     mLoadGroup->AddRequest(this, nsnull);
 150     mIsInLoadGroup = PR_TRUE;
 151   }
 152 }
 153
 154 void imgRequestProxy::RemoveFromLoadGroup(PRBool releaseLoadGroup)
 155 {
 156   if (!mIsInLoadGroup)
 157     return;
 158
 159   /* calling RemoveFromLoadGroup may cause the document to finish
 160      loading, which could result in our death.  We need to make sure
 161      that we stay alive long enough to fight another battle... at
 162      least until we exit this function.
 163   */
 164   nsCOMPtr<imgIRequest> kungFuDeathGrip(this);
 165
 166   mLoadGroup->RemoveRequest(this, NS_OK, nsnull);
 167   mIsInLoadGroup = PR_FALSE;
 168
 169   if (releaseLoadGroup) {
 170     // We're done with the loadgroup, release it.
 171     mLoadGroup = nsnull;
 172   }
 173 }
 174
 175
 176 /**  nsIRequest / imgIRequest methods **/
 177
 178 /* readonly attribute wstring name; */
 179 NS_IMETHODIMP imgRequestProxy::GetName(nsACString &aName)
 180 {
 181   aName.Truncate();
 182   if (mOwner) {
 183     nsCOMPtr<nsIURI> uri;
 184     mOwner->GetURI(getter_AddRefs(uri));
 185     if (uri)
 186       uri->GetSpec(aName);
 187   }
 188   return NS_OK;
 189 }
 190
 191 /* boolean isPending (); */
 192 NS_IMETHODIMP imgRequestProxy::IsPending(PRBool *_retval)
 193 {
 194   return NS_ERROR_NOT_IMPLEMENTED;
 195 }
 196
 197 /* readonly attribute nsresult status; */
 198 NS_IMETHODIMP imgRequestProxy::GetStatus(nsresult *aStatus)
 199 {
 200   if (!mOwner)
 201     return NS_ERROR_FAILURE;
 202
 203   *aStatus = mOwner->GetNetworkStatus();
 204
 205   return NS_OK;
 206 }
 207
 208 /* void cancel (in nsresult status); */
 209 NS_IMETHODIMP imgRequestProxy::Cancel(nsresult status)
 210 {
 211   if (mCanceled || !mOwner)
 212     return NS_ERROR_FAILURE;
 213
 214   LOG_SCOPE(gImgLog, "imgRequestProxy::Cancel");
 215
 216   mCanceled = PR_TRUE;
 217
 218   // Passing false to aNotify means that mListener will still get
 219   // OnStopRequest, if needed.
 220   mOwner->RemoveProxy(this, status, PR_FALSE);
 221
 222   NullOutListener();
 223
 224   return NS_OK;
 225 }
 226
 227 /* void suspend (); */
 228 NS_IMETHODIMP imgRequestProxy::Suspend()
 229 {
 230     return NS_ERROR_NOT_IMPLEMENTED;
 231 }
 232
 233 /* void resume (); */
 234 NS_IMETHODIMP imgRequestProxy::Resume()
 235 {
 236     return NS_ERROR_NOT_IMPLEMENTED;
 237 }
 238
 239 /* attribute nsILoadGroup loadGroup */
 240 NS_IMETHODIMP imgRequestProxy::GetLoadGroup(nsILoadGroup **loadGroup)
 241 {
 242   NS_IF_ADDREF(*loadGroup = mLoadGroup.get());
 243   return NS_OK;
 244 }
 245 NS_IMETHODIMP imgRequestProxy::SetLoadGroup(nsILoadGroup *loadGroup)
 246 {
 247   mLoadGroup = loadGroup;
 248   return NS_OK;
 249 }
 250
 251 /* attribute nsLoadFlags loadFlags */
 252 NS_IMETHODIMP imgRequestProxy::GetLoadFlags(nsLoadFlags *flags)
 253 {
 254   *flags = mLoadFlags;
 255   return NS_OK;
 256 }
 257 NS_IMETHODIMP imgRequestProxy::SetLoadFlags(nsLoadFlags flags)
 258 {
 259   mLoadFlags = flags;
 260   return NS_OK;
 261 }
 262
 263 /**  imgIRequest methods **/
 264
 265 /* attribute imgIContainer image; */
 266 NS_IMETHODIMP imgRequestProxy::GetImage(imgIContainer * *aImage)
 267 {
 268   if (!mOwner)
 269     return NS_ERROR_FAILURE;
 270
 271   mOwner->GetImage(aImage);
 272   return NS_OK;
 273 }
 274
 275 /* readonly attribute unsigned long imageStatus; */
 276 NS_IMETHODIMP imgRequestProxy::GetImageStatus(PRUint32 *aStatus)
 277 {
 278   if (!mOwner) {
 279     *aStatus = imgIRequest::STATUS_ERROR;
 280     return NS_ERROR_FAILURE;
 281   }
 282
 283   *aStatus = mOwner->GetImageStatus();
 284   return NS_OK;
 285 }
 286
 287 /* readonly attribute nsIURI URI; */
 288 NS_IMETHODIMP imgRequestProxy::GetURI(nsIURI **aURI)
 289 {
 290   if (!mOwner)
 291     return NS_ERROR_FAILURE;
 292
 293   return mOwner->GetURI(aURI);
 294 }
 295
 296 /* readonly attribute imgIDecoderObserver decoderObserver; */
 297 NS_IMETHODIMP imgRequestProxy::GetDecoderObserver(imgIDecoderObserver **aDecoderObserver)
 298 {
 299   *aDecoderObserver = mListener;
 300   NS_IF_ADDREF(*aDecoderObserver);
 301   return NS_OK;
 302 }
 303
 304 /* readonly attribute string mimeType; */
 305 NS_IMETHODIMP imgRequestProxy::GetMimeType(char **aMimeType)
 306 {
 307   if (!mOwner)
 308     return NS_ERROR_FAILURE;
 309
 310   const char *type = mOwner->GetMimeType();
 311   if (!type)
 312     return NS_ERROR_FAILURE;
 313
 314   *aMimeType = nsCRT::strdup(type);
 315
 316   return NS_OK;
 317 }
 318
 319 NS_IMETHODIMP imgRequestProxy::Clone(imgIDecoderObserver* aObserver,
 320                                      imgIRequest** aClone)
 321 {
 322   NS_PRECONDITION(aClone, "Null out param");
 323   *aClone = nsnull;
 324   imgRequestProxy* clone = new imgRequestProxy();
 325   if (!clone) {
 326     return NS_ERROR_OUT_OF_MEMORY;
 327   }
 328   NS_ADDREF(clone);
 329
 330   // It is important to call |SetLoadFlags()| before calling |Init()| because
 331   // |Init()| adds the request to the loadgroup.
 332   // When a request is added to a loadgroup, its load flags are merged
 333   // with the load flags of the loadgroup.
 334   // XXXldb That's not true anymore.  Stuff from imgLoader adds the
 335   // request to the loadgroup.
 336   clone->SetLoadFlags(mLoadFlags);
 337   nsresult rv = clone->Init(mOwner, mLoadGroup, aObserver);
 338   if (NS_FAILED(rv)) {
 339     NS_RELEASE(clone);
 340     return rv;
 341   }
 342
 343   // Assign to *aClone before calling NotifyProxyListener so that if
 344   // the caller expects to only be notified for requests it's already
 345   // holding pointers to it won't be surprised.
 346   *aClone = clone;
 347
 348   // Send the notifications to the clone's observer
 349   mOwner->NotifyProxyListener(clone);
 350
 351   return NS_OK;
 352 }
 353
 354 /* readonly attribute nsIPrincipal imagePrincipal; */
 355 NS_IMETHODIMP imgRequestProxy::GetImagePrincipal(nsIPrincipal **aPrincipal)
 356 {
 357   if (!mOwner)
 358     return NS_ERROR_FAILURE;
 359
 360   return mOwner->GetPrincipal(aPrincipal);
 361 }
 362
 363 /** nsISupportsPriority methods **/
 364
 365 NS_IMETHODIMP imgRequestProxy::GetPriority(PRInt32 *priority)
 366 {
 367   NS_ENSURE_STATE(mOwner);
 368   *priority = mOwner->Priority();
 369   return NS_OK;
 370 }
 371
 372 NS_IMETHODIMP imgRequestProxy::SetPriority(PRInt32 priority)
 373 {
 374   NS_ENSURE_STATE(mOwner && !mCanceled);
 375   mOwner->AdjustPriority(this, priority - mOwner->Priority());
 376   return NS_OK;
 377 }
 378
 379 NS_IMETHODIMP imgRequestProxy::AdjustPriority(PRInt32 priority)
 380 {
 381   NS_ENSURE_STATE(mOwner && !mCanceled);
 382   mOwner->AdjustPriority(this, priority);
 383   return NS_OK;
 384 }
 385
 386 /** imgIContainerObserver methods **/
 387
 388 void imgRequestProxy::FrameChanged(imgIContainer *container, gfxIImageFrame *newframe, nsIntRect * dirtyRect)
 389 {
 390   LOG_FUNC(gImgLog, "imgRequestProxy::FrameChanged");
 391
 392   if (mListener) {
 393     // Hold a ref to the listener while we call it, just in case.
 394     nsCOMPtr<imgIDecoderObserver> kungFuDeathGrip(mListener);
 395     mListener->FrameChanged(container, newframe, dirtyRect);
 396   }
 397 }
 398
 399 /** imgIDecoderObserver methods **/
 400
 401 void imgRequestProxy::OnStartDecode()
 402 {
 403   LOG_FUNC(gImgLog, "imgRequestProxy::OnStartDecode");
 404
 405   if (mListener) {
 406     // Hold a ref to the listener while we call it, just in case.
 407     nsCOMPtr<imgIDecoderObserver> kungFuDeathGrip(mListener);
 408     mListener->OnStartDecode(this);
 409   }
 410 }
 411
 412 void imgRequestProxy::OnStartContainer(imgIContainer *image)
 413 {
 414   LOG_FUNC(gImgLog, "imgRequestProxy::OnStartContainer");
 415
 416   if (mListener) {
 417     // Hold a ref to the listener while we call it, just in case.
 418     nsCOMPtr<imgIDecoderObserver> kungFuDeathGrip(mListener);
 419     mListener->OnStartContainer(this, image);
 420   }
 421 }
 422
 423 void imgRequestProxy::OnStartFrame(gfxIImageFrame *frame)
 424 {
 425   LOG_FUNC(gImgLog, "imgRequestProxy::OnStartFrame");
 426
 427   if (mListener) {
 428     // Hold a ref to the listener while we call it, just in case.
 429     nsCOMPtr<imgIDecoderObserver> kungFuDeathGrip(mListener);
 430     mListener->OnStartFrame(this, frame);
 431   }
 432 }
 433
 434 void imgRequestProxy::OnDataAvailable(gfxIImageFrame *frame, const nsIntRect * rect)
 435 {
 436   LOG_FUNC(gImgLog, "imgRequestProxy::OnDataAvailable");
 437
 438   if (mListener) {
 439     // Hold a ref to the listener while we call it, just in case.
 440     nsCOMPtr<imgIDecoderObserver> kungFuDeathGrip(mListener);
 441     mListener->OnDataAvailable(this, frame, rect);
 442   }
 443 }
 444
 445 void imgRequestProxy::OnStopFrame(gfxIImageFrame *frame)
 446 {
 447   LOG_FUNC(gImgLog, "imgRequestProxy::OnStopFrame");
 448
 449   if (mListener) {
 450     // Hold a ref to the listener while we call it, just in case.
 451     nsCOMPtr<imgIDecoderObserver> kungFuDeathGrip(mListener);
 452     mListener->OnStopFrame(this, frame);
 453   }
 454 }
 455
 456 void imgRequestProxy::OnStopContainer(imgIContainer *image)
 457 {
 458   LOG_FUNC(gImgLog, "imgRequestProxy::OnStopContainer");
 459
 460   if (mListener) {
 461     // Hold a ref to the listener while we call it, just in case.
 462     nsCOMPtr<imgIDecoderObserver> kungFuDeathGrip(mListener);
 463     mListener->OnStopContainer(this, image);
 464   }
 465 }
 466
 467 void imgRequestProxy::OnStopDecode(nsresult status, const PRUnichar *statusArg)
 468 {
 469   LOG_FUNC(gImgLog, "imgRequestProxy::OnStopDecode");
 470
 471   if (mListener) {
 472     // Hold a ref to the listener while we call it, just in case.
 473     nsCOMPtr<imgIDecoderObserver> kungFuDeathGrip(mListener);
 474     mListener->OnStopDecode(this, status, statusArg);
 475   }
 476 }
 477
 478
 479
 480 void imgRequestProxy::OnStartRequest(nsIRequest *request, nsISupports *ctxt)
 481 {
 482 #ifdef PR_LOGGING
 483   nsCAutoString name;
 484   GetName(name);
 485   LOG_FUNC_WITH_PARAM(gImgLog, "imgRequestProxy::OnStartRequest", "name", name.get());
 486 #endif
 487
 488   if (mListener) {
 489     // Hold a ref to the listener while we call it, just in case.
 490     nsCOMPtr<imgIDecoderObserver> kungFuDeathGrip(mListener);
 491     mListener->OnStartRequest(this);
 492   }
 493 }
 494
 495 void imgRequestProxy::OnStopRequest(nsIRequest *request, nsISupports *ctxt,
 496                                     nsresult statusCode, PRBool lastPart)
 497 {
 498 #ifdef PR_LOGGING
 499   nsCAutoString name;
 500   GetName(name);
 501   LOG_FUNC_WITH_PARAM(gImgLog, "imgRequestProxy::OnStopRequest", "name", name.get());
 502 #endif
 503   // There's all sorts of stuff here that could kill us (the OnStopRequest call
 504   // on the listener, the removal from the loadgroup, the release of the
 505   // listener, etc).  Don't let them do it.
 506   nsCOMPtr<imgIRequest> kungFuDeathGrip(this);
 507
 508   if (mListener) {
 509     // Hold a ref to the listener while we call it, just in case.
 510     nsCOMPtr<imgIDecoderObserver> kungFuDeathGrip(mListener);
 511     mListener->OnStopRequest(this, lastPart);
 512   }
 513
 514   // If we're expecting more data from a multipart channel, re-add ourself
 515   // to the loadgroup so that the document doesn't lose track of the load.
 516   // If the request is already a background request and there's more data
 517   // coming, we can just leave the request in the loadgroup as-is.
 518   if (lastPart || (mLoadFlags & nsIRequest::LOAD_BACKGROUND) == 0) {
 519     RemoveFromLoadGroup(lastPart);
 520     // More data is coming, so change the request to be a background request
 521     // and put it back in the loadgroup.
 522     if (!lastPart) {
 523       mLoadFlags |= nsIRequest::LOAD_BACKGROUND;
 524       AddToLoadGroup();
 525     }
 526   }
 527
 528   if (mListenerIsStrongRef) {
 529     NS_PRECONDITION(mListener, "How did that happen?");
 530     // Drop our strong ref to the listener now that we're done with
 531     // everything.  Note that this can cancel us and other fun things
 532     // like that.  Don't add anything in this method after this point.
 533     imgIDecoderObserver* obs = mListener;
 534     mListenerIsStrongRef = PR_FALSE;
 535     NS_RELEASE(obs);
 536   }
 537 }
 538
 539 void imgRequestProxy::NullOutListener()
 540 {
 541   if (mListenerIsStrongRef) {
 542     // Releasing could do weird reentery stuff, so just play it super-safe
 543     nsCOMPtr<imgIDecoderObserver> obs;
 544     obs.swap(mListener);
 545     mListenerIsStrongRef = PR_FALSE;
 546   } else {
 547     mListener = nsnull;
 548   }
 549 }