The Tor Browser: toolkit/components/downloads/nsDownloadProxy.h@925c144e1f1f

     1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

     2 /* This Source Code Form is subject to the terms of the Mozilla Public

     3  * License, v. 2.0. If a copy of the MPL was not distributed with this

     4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     6 #ifndef downloadproxy___h___

     7 #define downloadproxy___h___

     9 #include "nsIDownloadManager.h"

    10 #include "nsIPrefBranch.h"

    11 #include "nsIPrefService.h"

    12 #include "nsIMIMEInfo.h"

    13 #include "nsIFileURL.h"

    14 #include "nsIDownloadManagerUI.h"

    16 #define PREF_BDM_SHOWWHENSTARTING "browser.download.manager.showWhenStarting"

    17 #define PREF_BDM_FOCUSWHENSTARTING "browser.download.manager.focusWhenStarting"

    19 // This class only exists because nsDownload cannot inherit from nsITransfer

    20 // directly. The reason for this is that nsDownloadManager (incorrectly) keeps

    21 // an nsCOMArray of nsDownloads, and nsCOMArray is only intended for use with

    22 // abstract classes. Using a concrete class that multiply inherits from classes

    23 // deriving from nsISupports will throw ambiguous base class errors.

    24 class nsDownloadProxy : public nsITransfer

    25 {

    26 public:

    28   nsDownloadProxy() { }

    29   virtual ~nsDownloadProxy() { }

    31   NS_DECL_ISUPPORTS

    33   NS_IMETHODIMP Init(nsIURI* aSource,

    34                      nsIURI* aTarget,

    35                      const nsAString& aDisplayName,

    36                      nsIMIMEInfo *aMIMEInfo,

    37                      PRTime aStartTime,

    38                      nsIFile* aTempFile,

    39                      nsICancelable* aCancelable,

    40                      bool aIsPrivate) {

    41     nsresult rv;

    42     nsCOMPtr<nsIDownloadManager> dm = do_GetService("@mozilla.org/download-manager;1", &rv);

    43     NS_ENSURE_SUCCESS(rv, rv);

    45     rv = dm->AddDownload(nsIDownloadManager::DOWNLOAD_TYPE_DOWNLOAD, aSource,

    46                          aTarget, aDisplayName, aMIMEInfo, aStartTime,

    47                          aTempFile, aCancelable, aIsPrivate,

    48                          getter_AddRefs(mInner));

    49     NS_ENSURE_SUCCESS(rv, rv);

    51     nsCOMPtr<nsIPrefService> prefs = do_GetService("@mozilla.org/preferences-service;1", &rv);

    52     NS_ENSURE_SUCCESS(rv, rv);

    53     nsCOMPtr<nsIPrefBranch> branch = do_QueryInterface(prefs);

    55     bool showDM = true;

    56     if (branch)

    57       branch->GetBoolPref(PREF_BDM_SHOWWHENSTARTING, &showDM);

    59     if (showDM) {

    60       nsCOMPtr<nsIDownloadManagerUI> dmui =

    61         do_GetService("@mozilla.org/download-manager-ui;1", &rv);

    62       NS_ENSURE_SUCCESS(rv, rv);

    64       bool visible;

    65       rv = dmui->GetVisible(&visible);

    66       NS_ENSURE_SUCCESS(rv, rv);

    68       bool focusWhenStarting = true;

    69       if (branch)

    70         (void)branch->GetBoolPref(PREF_BDM_FOCUSWHENSTARTING, &focusWhenStarting);

    72       if (visible && !focusWhenStarting)

    73         return NS_OK;

    75       return dmui->Show(nullptr, mInner, nsIDownloadManagerUI::REASON_NEW_DOWNLOAD, aIsPrivate);

    76     }

    77     return rv;

    78   }

    80   NS_IMETHODIMP OnStateChange(nsIWebProgress* aWebProgress,

    81                               nsIRequest* aRequest, uint32_t aStateFlags,

    82                               nsresult aStatus)

    83   {

    84     NS_ENSURE_TRUE(mInner, NS_ERROR_NOT_INITIALIZED);

    85     return mInner->OnStateChange(aWebProgress, aRequest, aStateFlags, aStatus);

    86   }

    88   NS_IMETHODIMP OnStatusChange(nsIWebProgress *aWebProgress,

    89                                nsIRequest *aRequest, nsresult aStatus,

    90                                const char16_t *aMessage)

    91   {

    92     NS_ENSURE_TRUE(mInner, NS_ERROR_NOT_INITIALIZED);

    93     return mInner->OnStatusChange(aWebProgress, aRequest, aStatus, aMessage);

    94   }

    96   NS_IMETHODIMP OnLocationChange(nsIWebProgress *aWebProgress,

    97                                  nsIRequest *aRequest, nsIURI *aLocation,

    98                                  uint32_t aFlags)

    99   {

   100     NS_ENSURE_TRUE(mInner, NS_ERROR_NOT_INITIALIZED);

   101     return mInner->OnLocationChange(aWebProgress, aRequest, aLocation, aFlags);

   102   }

   104   NS_IMETHODIMP OnProgressChange(nsIWebProgress *aWebProgress,

   105                                  nsIRequest *aRequest,

   106                                  int32_t aCurSelfProgress,

   107                                  int32_t aMaxSelfProgress,

   108                                  int32_t aCurTotalProgress,

   109                                  int32_t aMaxTotalProgress)

   110   {

   111     NS_ENSURE_TRUE(mInner, NS_ERROR_NOT_INITIALIZED);

   112     return mInner->OnProgressChange(aWebProgress, aRequest,

   113                                     aCurSelfProgress,

   114                                     aMaxSelfProgress,

   115                                     aCurTotalProgress,

   116                                     aMaxTotalProgress);

   117   }

   119   NS_IMETHODIMP OnProgressChange64(nsIWebProgress *aWebProgress,

   120                                    nsIRequest *aRequest,

   121                                    int64_t aCurSelfProgress,

   122                                    int64_t aMaxSelfProgress,

   123                                    int64_t aCurTotalProgress,

   124                                    int64_t aMaxTotalProgress)

   125   {

   126     NS_ENSURE_TRUE(mInner, NS_ERROR_NOT_INITIALIZED);

   127     return mInner->OnProgressChange64(aWebProgress, aRequest,

   128                                       aCurSelfProgress,

   129                                       aMaxSelfProgress,

   130                                       aCurTotalProgress,

   131                                       aMaxTotalProgress);

   132   }

   134   NS_IMETHODIMP OnRefreshAttempted(nsIWebProgress *aWebProgress,

   135                                    nsIURI *aUri,

   136                                    int32_t aDelay,

   137                                    bool aSameUri,

   138                                    bool *allowRefresh)

   139   {

   140     *allowRefresh = true;

   141     return NS_OK;

   142   }

   144   NS_IMETHODIMP OnSecurityChange(nsIWebProgress *aWebProgress,

   145                                  nsIRequest *aRequest, uint32_t aState)

   146   {

   147     NS_ENSURE_TRUE(mInner, NS_ERROR_NOT_INITIALIZED);

   148     return mInner->OnSecurityChange(aWebProgress, aRequest, aState);

   149   }

   151   NS_IMETHODIMP SetSha256Hash(const nsACString& aHash)

   152   {

   153     NS_ENSURE_TRUE(mInner, NS_ERROR_NOT_INITIALIZED);

   154     return mInner->SetSha256Hash(aHash);

   155   }

   157   NS_IMETHODIMP SetSignatureInfo(nsIArray* aSignatureInfo)

   158   {

   159     NS_ENSURE_TRUE(mInner, NS_ERROR_NOT_INITIALIZED);

   160     return mInner->SetSignatureInfo(aSignatureInfo);

   161   }

   163 private:

   164   nsCOMPtr<nsIDownload> mInner;

   165 };

   167 NS_IMPL_ISUPPORTS(nsDownloadProxy, nsITransfer,

   168                   nsIWebProgressListener, nsIWebProgressListener2)

   170 #endif

The Tor Browser / file revision