The Tor Browser: uriloader/exthandler/nsExternalHelperAppService.h@6474c204b198 (annotated)

uriloader/exthandler/nsExternalHelperAppService.h@6474c204b198 (annotated)

uriloader/exthandler/nsExternalHelperAppService.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #ifndef nsExternalHelperAppService_h__
 #define nsExternalHelperAppService_h__
 #ifdef MOZ_LOGGING
 #define FORCE_PR_LOG
 #endif
 #include "prlog.h"
 #include "prtime.h"
 #include "nsIExternalHelperAppService.h"
 #include "nsIExternalProtocolService.h"
 #include "nsIWebProgressListener2.h"
 #include "nsIHelperAppLauncherDialog.h"
 #include "nsIMIMEInfo.h"
 #include "nsIMIMEService.h"
 #include "nsIStreamListener.h"
 #include "nsIFile.h"
 #include "nsIFileStreams.h"
 #include "nsIOutputStream.h"
 #include "nsString.h"
 #include "nsIInterfaceRequestor.h"
 #include "nsIInterfaceRequestorUtils.h"
 #include "nsIChannel.h"
 #include "nsITimer.h"
 #include "nsIBackgroundFileSaver.h"
 #include "nsIHandlerService.h"
 #include "nsCOMPtr.h"
 #include "nsIObserver.h"
 #include "nsCOMArray.h"
 #include "nsWeakReference.h"
 #include "nsIPrompt.h"
 #include "nsAutoPtr.h"
 #include "mozilla/Attributes.h"
 #include "necko-config.h"
 class nsExternalAppHandler;
 class nsIMIMEInfo;
 class nsITransfer;
 class nsIDOMWindow;
 /**
  * The helper app service. Responsible for handling content that Mozilla
  * itself can not handle
  */
 class nsExternalHelperAppService
 : public nsIExternalHelperAppService,
   public nsPIExternalAppLauncher,
   public nsIExternalProtocolService,
   public nsIMIMEService,
   public nsIObserver,
   public nsSupportsWeakReference
 {
 public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSIEXTERNALHELPERAPPSERVICE
   NS_DECL_NSPIEXTERNALAPPLAUNCHER
   NS_DECL_NSIEXTERNALPROTOCOLSERVICE
   NS_DECL_NSIMIMESERVICE
   NS_DECL_NSIOBSERVER
   nsExternalHelperAppService();
   virtual ~nsExternalHelperAppService();
   /**
    * Initializes internal state. Will be called automatically when
    * this service is first instantiated.
    */
   NS_HIDDEN_(nsresult) Init();
   /**
    * Given a mimetype and an extension, looks up a mime info from the OS.
    * The mime type is given preference. This function follows the same rules
    * as nsIMIMEService::GetFromTypeAndExtension.
    * This is supposed to be overridden by the platform-specific
    * nsOSHelperAppService!
    * @param aFileExt The file extension; may be empty. UTF-8 encoded.
    * @param [out] aFound
    *        Should be set to true if the os has a mapping, to
    *        false otherwise. Must not be null.
    * @return A MIMEInfo. This function must return a MIMEInfo object if it
    *         can allocate one.  The only justifiable reason for not
    *         returning one is an out-of-memory error.
    *         If null, the value of aFound is unspecified.
    */
   virtual already_AddRefed<nsIMIMEInfo> GetMIMEInfoFromOS(const nsACString& aMIMEType,
                                                           const nsACString& aFileExt,
                                                           bool       * aFound) = 0;
   /**
    * Given a string identifying an application, create an nsIFile representing
    * it. This function should look in $PATH for the application.
    * The base class implementation will first try to interpret platformAppPath
    * as an absolute path, and if that fails it will look for a file next to the
    * mozilla executable. Subclasses can override this method if they want a
    * different behaviour.
    * @param platformAppPath A platform specific path to an application that we
    *                        got out of the rdf data source. This can be a mac
    *                        file spec, a unix path or a windows path depending
    *                        on the platform
    * @param aFile           [out] An nsIFile representation of that platform
    *                        application path.
    */
   virtual nsresult GetFileTokenForPath(const char16_t * platformAppPath,
                                        nsIFile ** aFile);
   virtual NS_HIDDEN_(nsresult) OSProtocolHandlerExists(const char *aScheme,
                                                        bool *aExists) = 0;
 protected:
   /**
    * Searches the "extra" array of MIMEInfo objects for an object
    * with a specific type. If found, it will modify the passed-in
    * MIMEInfo. Otherwise, it will return an error and the MIMEInfo
    * will be untouched.
    * @param aContentType The type to search for.
    * @param aMIMEInfo    [inout] The mime info, if found
    */
   NS_HIDDEN_(nsresult) FillMIMEInfoForMimeTypeFromExtras(
     const nsACString& aContentType, nsIMIMEInfo * aMIMEInfo);
   /**
    * Searches the "extra" array of MIMEInfo objects for an object
    * with a specific extension.
    *
    * Does not change the MIME Type of the MIME Info.
    *
    * @see FillMIMEInfoForMimeTypeFromExtras
    */
   NS_HIDDEN_(nsresult) FillMIMEInfoForExtensionFromExtras(
     const nsACString& aExtension, nsIMIMEInfo * aMIMEInfo);
   /**
    * Searches the "extra" array for a MIME type, and gets its extension.
    * @param aExtension The extension to search for
    * @param aMIMEType [out] The found MIME type.
    * @return true if the extension was found, false otherwise.
    */
   NS_HIDDEN_(bool) GetTypeFromExtras(const nsACString& aExtension,
                                        nsACString& aMIMEType);
 #ifdef PR_LOGGING
   /**
    * NSPR Logging Module. Usage: set NSPR_LOG_MODULES=HelperAppService:level,
    * where level should be 2 for errors, 3 for debug messages from the cross-
    * platform nsExternalHelperAppService, and 4 for os-specific debug messages.
    */
   static PRLogModuleInfo* mLog;
 #endif
   // friend, so that it can access the nspr log module.
   friend class nsExternalAppHandler;
   /**
    * Helper function for ExpungeTemporaryFiles and ExpungeTemporaryPrivateFiles
    */
   static void ExpungeTemporaryFilesHelper(nsCOMArray<nsIFile> &fileList);
   /**
    * Helper function for DeleteTemporaryFileOnExit and DeleteTemporaryPrivateFileWhenPossible
    */
   static nsresult DeleteTemporaryFileHelper(nsIFile* aTemporaryFile,
                                             nsCOMArray<nsIFile> &aFileList);
   /**
    * Functions related to the tempory file cleanup service provided by
    * nsExternalHelperAppService
    */
   void ExpungeTemporaryFiles();
   /**
    * Functions related to the tempory file cleanup service provided by
    * nsExternalHelperAppService (for the temporary files added during
    * the private browsing mode)
    */
   void ExpungeTemporaryPrivateFiles();
 #ifdef NECKO_PROTOCOL_rtsp
   /**
    * Launch video app for rtsp protocol. This function is supported only on Gonk
    * for now.
    */
   static void LaunchVideoAppForRtsp(nsIURI* aURI);
 #endif
   /**
    * Array for the files that should be deleted
    */
   nsCOMArray<nsIFile> mTemporaryFilesList;
   /**
    * Array for the files that should be deleted (for the temporary files
    * added during the private browsing mode)
    */
   nsCOMArray<nsIFile> mTemporaryPrivateFilesList;
 };
 /**
  * An external app handler is just a small little class that presents itself as
  * a nsIStreamListener. It saves the incoming data into a temp file. The handler
  * is bound to an application when it is created. When it receives an
  * OnStopRequest it launches the application using the temp file it has
  * stored the data into.  We create a handler every time we have to process
  * data using a helper app.
  */
 class nsExternalAppHandler MOZ_FINAL : public nsIStreamListener,
                                        public nsIHelperAppLauncher,
                                        public nsITimerCallback,
                                        public nsIBackgroundFileSaverObserver
 {
 public:
   NS_DECL_THREADSAFE_ISUPPORTS
   NS_DECL_NSISTREAMLISTENER
   NS_DECL_NSIREQUESTOBSERVER
   NS_DECL_NSIHELPERAPPLAUNCHER
   NS_DECL_NSICANCELABLE
   NS_DECL_NSITIMERCALLBACK
   NS_DECL_NSIBACKGROUNDFILESAVEROBSERVER
   /**
    * @param aMIMEInfo      MIMEInfo object, representing the type of the
    *                       content that should be handled
    * @param aFileExtension The extension we need to append to our temp file,
    *                       INCLUDING the ".". e.g. .mp3
    * @param aWindowContext Window context, as passed to DoContent
    * @param mExtProtSvc    nsExternalHelperAppService on creation
    * @param aFileName      The filename to use
    * @param aReason        A constant from nsIHelperAppLauncherDialog indicating
    *                       why the request is handled by a helper app.
    */
   nsExternalAppHandler(nsIMIMEInfo * aMIMEInfo, const nsCSubstring& aFileExtension,
                        nsIInterfaceRequestor * aWindowContext,
                        nsExternalHelperAppService * aExtProtSvc,
                        const nsAString& aFilename,
                        uint32_t aReason, bool aForceSave);
   ~nsExternalAppHandler();
   /**
    * Clean up after the request was diverted to the parent process.
    */
   void DidDivertRequest(nsIRequest *request);
 protected:
   nsCOMPtr<nsIFile> mTempFile;
   nsCOMPtr<nsIURI> mSourceUrl;
   nsString mTempFileExtension;
   nsString mTempLeafName;
   /**
    * The MIME Info for this load. Will never be null.
    */
   nsCOMPtr<nsIMIMEInfo> mMimeInfo;
   nsCOMPtr<nsIInterfaceRequestor> mWindowContext;
   /**
    * Used to close the window on a timer, to avoid any exceptions that are
    * thrown if we try to close the window before it's fully loaded.
    */
   nsCOMPtr<nsIDOMWindow> mWindowToClose;
   nsCOMPtr<nsITimer> mTimer;
   /**
    * The following field is set if we were processing an http channel that had
    * a content disposition header which specified the SUGGESTED file name we
    * should present to the user in the save to disk dialog.
    */
   nsString mSuggestedFileName;
   /**
    * If set, this handler should forcibly save the file to disk regardless of
    * MIME info settings or anything else, without ever popping up the
    * unknown content type handling dialog.
    */
   bool mForceSave;
   /**
    * The canceled flag is set if the user canceled the launching of this
    * application before we finished saving the data to a temp file.
    */
   bool mCanceled;
   /**
    * This is set based on whether the channel indicates that a new window
    * was opened specifically for this download.  If so, then we
    * close it.
    */
   bool mShouldCloseWindow;
   /**
    * True if a stop request has been issued.
    */
   bool mStopRequestIssued;
   bool mIsFileChannel;
   /**
    * One of the REASON_ constants from nsIHelperAppLauncherDialog. Indicates the
    * reason the dialog was shown (unknown content type, server requested it,
    * etc).
    */
   uint32_t mReason;
   /**
    * Track the executable-ness of the temporary file.
    */
   bool mTempFileIsExecutable;
   PRTime mTimeDownloadStarted;
   int64_t mContentLength;
   int64_t mProgress; /**< Number of bytes received (for sending progress notifications). */
   /**
    * When we are told to save the temp file to disk (in a more permament
    * location) before we are done writing the content to a temp file, then
    * we need to remember the final destination until we are ready to use it.
    */
   nsCOMPtr<nsIFile> mFinalFileDestination;
   uint32_t mBufferSize;
   /**
    * This object handles saving the data received from the network to a
    * temporary location first, and then move the file to its final location,
    * doing all the input/output on a background thread.
    */
   nsCOMPtr<nsIBackgroundFileSaver> mSaver;
   /**
    * Stores the SHA-256 hash associated with the file that we downloaded.
    */
   nsAutoCString mHash;
   /**
    * Stores the signature information of the downloaded file in an nsIArray of
    * nsIX509CertList of nsIX509Cert. If the file is unsigned this will be
    * empty.
    */
   nsCOMPtr<nsIArray> mSignatureInfo;
   /**
    * Creates the temporary file for the download and an output stream for it.
    * Upon successful return, both mTempFile and mSaver will be valid.
    */
   nsresult SetUpTempFile(nsIChannel * aChannel);
   /**
    * When we download a helper app, we are going to retarget all load
    * notifications into our own docloader and load group instead of
    * using the window which initiated the load....RetargetLoadNotifications
    * contains that information...
    */
   void RetargetLoadNotifications(nsIRequest *request);
   /**
    * Once the user tells us how they want to dispose of the content
    * create an nsITransfer so they know what's going on. If this fails, the
    * caller MUST call Cancel.
    */
   nsresult CreateTransfer();
   /**
    * If we fail to create the necessary temporary file to initiate a transfer
    * we will report the failure by creating a failed nsITransfer.
    */
   nsresult CreateFailedTransfer(bool aIsPrivateBrowsing);
   /*
    * The following two functions are part of the split of SaveToDisk
    * to make it async, and works as following:
    *
    *    SaveToDisk    ------->   RequestSaveDestination
    *                                     .
    *                                     .
    *                                     v
    *    ContinueSave  <-------   SaveDestinationAvailable
    */
   /**
    * This is called by SaveToDisk to decide what's the final
    * file destination chosen by the user or by auto-download settings.
    */
   void RequestSaveDestination(const nsAFlatString &aDefaultFile,
                               const nsAFlatString &aDefaultFileExt);
   /**
    * When SaveToDisk is called, it possibly delegates to RequestSaveDestination
    * to decide the file destination. ContinueSave must then be called when
    * the final destination is finally known.
    * @param  aFile  The file that was chosen as the final destination.
    *                Must not be null.
    */
   nsresult ContinueSave(nsIFile* aFile);
   /**
    * After we're done prompting the user for any information, if the original
    * channel had a refresh url associated with it (which might point to a
    * "thank you for downloading" kind of page, then process that....It is safe
    * to invoke this method multiple times. We'll clear mOriginalChannel after
    * it's called and this ensures we won't call it again....
    */
   void ProcessAnyRefreshTags();
   /**
    * Notify our nsITransfer object that we are done with the download.  This is
    * always called after the target file has been closed.
    *
    * @param aStatus
    *        NS_OK for success, or a failure code if the download failed.
    *        A partially downloaded file may still be available in this case.
    */
   void NotifyTransfer(nsresult aStatus);
   /**
    * Helper routine that searches a pref string for a given mime type
    */
   bool GetNeverAskFlagFromPref(const char * prefName, const char * aContentType);
   /**
    * Helper routine to ensure mSuggestedFileName is "correct";
    * this ensures that mTempFileExtension only contains an extension when it
    * is different from mSuggestedFileName's extension.
    */
   void EnsureSuggestedFileName();
   typedef enum { kReadError, kWriteError, kLaunchError } ErrorType;
   /**
    * Utility function to send proper error notification to web progress listener
    */
   void SendStatusChange(ErrorType type, nsresult aStatus, nsIRequest *aRequest, const nsAFlatString &path);
   /**
    * Closes the window context if it does not have a refresh header
    * and it never displayed content before the external helper app
    * service was invoked.
    */
   nsresult MaybeCloseWindow();
   /**
    * Set in nsHelperDlgApp.js. This is always null after the user has chosen an
    * action.
    */
   nsCOMPtr<nsIWebProgressListener2> mDialogProgressListener;
   /**
    * Set once the user has chosen an action. This is null after the download
    * has been canceled or completes.
    */
   nsCOMPtr<nsITransfer> mTransfer;
   nsCOMPtr<nsIChannel> mOriginalChannel; /**< in the case of a redirect, this will be the pre-redirect channel. */
   nsCOMPtr<nsIHelperAppLauncherDialog> mDialog;
   /**
    * Keep request alive in case when helper non-modal dialog shown.
    * Thus in OnStopRequest the mRequest will not be set to null (it will be set to null further).
    */
   bool mKeepRequestAlive;
   /**
    * The request that's being loaded. Initialized in OnStartRequest.
    * Nulled out in OnStopRequest or once we know what we're doing
    * with the data, whichever happens later.
    */
   nsCOMPtr<nsIRequest> mRequest;
   nsRefPtr<nsExternalHelperAppService> mExtProtSvc;
 };
 #endif // nsExternalHelperAppService_h__

The Tor Browser / annotate

uriloader/exthandler/nsExternalHelperAppService.h@6474c204b198 (annotated)

uriloader/exthandler/nsExternalHelperAppService.h