embed/mozilla/mozilla-embed-persist.cpp

   1 /*
   2  *  Copyright © 2000, 2001, 2002 Marco Pesenti Gritti
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License as published by
   6  *  the Free Software Foundation; either version 2, or (at your option)
   7  *  any later version.
   8  *
   9  *  This program is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *  GNU General Public License for more details.
  13  *
  14  *  You should have received a copy of the GNU General Public License
  15  *  along with this program; if not, write to the Free Software
  16  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  *  $Id: mozilla-embed-persist.cpp 6952 2007-03-11 19:42:02Z chpe $
  19  */
  20
  21 #include "mozilla-config.h"
  22 #include "config.h"
  23
  24 #include <stddef.h>
  25
  26 #include <nsStringAPI.h>
  27
  28 #include <nsCOMPtr.h>
  29 #include <nsComponentManagerUtils.h>
  30 #include <nsCWebBrowserPersist.h>
  31 #include <nsICacheEntryDescriptor.h>
  32 #include <nsICacheService.h>
  33 #include <nsICacheSession.h>
  34 #include <nsIDOMSerializer.h>
  35 #include <nsIFile.h>
  36 #include <nsIHistoryEntry.h>
  37 #include <nsIInputStream.h>
  38 #include <nsIIOService.h>
  39 #include <nsILocalFile.h>
  40 #include <nsISHEntry.h>
  41 #include <nsIURI.h>
  42 #include <nsIWebBrowserPersist.h>
  43 #include <nsNetCID.h>
  44 #include <nsNetError.h>
  45 #include <nsServiceManagerUtils.h>
  46 #include <nsXPCOM.h>
  47
  48 #include "EphyBrowser.h"
  49 #include "EphyHeaderSniffer.h"
  50 #include "EphyUtils.h"
  51 #include "MozDownload.h"
  52
  53 #include "ephy-debug.h"
  54 #include "ephy-embed-shell.h"
  55 #include "ephy-file-helpers.h"
  56 #include "mozilla-embed.h"
  57
  58 #include "mozilla-embed-persist.h"
  59
  60 static void
  61 mozilla_embed_persist_class_init (MozillaEmbedPersistClass *klass);
  62 static void
  63 mozilla_embed_persist_init (MozillaEmbedPersist *ges);
  64 static void
  65 mozilla_embed_persist_finalize (GObject *object);
  66
  67 #define MOZILLA_EMBED_PERSIST_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), MOZILLA_TYPE_EMBED_PERSIST, MozillaEmbedPersistPrivate))
  68
  69 struct MozillaEmbedPersistPrivate
  70 {
  71         nsCOMPtr<nsIWebBrowserPersist> mPersist;
  72 };
  73
  74 static GObjectClass *parent_class = NULL;
  75
  76 GType
  77 mozilla_embed_persist_get_type (void)
  78 {
  79        static GType type = 0;
  80
  81         if (G_UNLIKELY (type == 0))
  82         {
  83                 const GTypeInfo our_info =
  84                 {
  85                         sizeof (MozillaEmbedPersistClass),
  86                         NULL, /* base_init */
  87                         NULL, /* base_finalize */
  88                         (GClassInitFunc) mozilla_embed_persist_class_init,
  89                         NULL, /* class_finalize */
  90                         NULL, /* class_data */
  91                         sizeof (MozillaEmbedPersist),
  92                         0,    /* n_preallocs */
  93                         (GInstanceInitFunc) mozilla_embed_persist_init
  94                 };
  95
  96                 type = g_type_register_static (EPHY_TYPE_EMBED_PERSIST,
  97                                                "MozillaEmbedPersist",
  98                                                &our_info, (GTypeFlags) 0);
  99         }
 100
 101         return type;
 102 }
 103
 104 static void
 105 mozilla_embed_persist_init (MozillaEmbedPersist *persist)
 106 {
 107         persist->priv = MOZILLA_EMBED_PERSIST_GET_PRIVATE (persist);
 108
 109         persist->priv->mPersist = do_CreateInstance (NS_WEBBROWSERPERSIST_CONTRACTID);
 110 }
 111
 112 static void
 113 mozilla_embed_persist_finalize (GObject *object)
 114 {
 115         MozillaEmbedPersist *persist = MOZILLA_EMBED_PERSIST (object);
 116
 117         persist->priv->mPersist = nsnull;
 118
 119         G_OBJECT_CLASS (parent_class)->finalize (object);
 120 }
 121
 122 void
 123 mozilla_embed_persist_completed (MozillaEmbedPersist *persist)
 124 {
 125         g_signal_emit_by_name (persist, "completed");
 126         g_object_unref (persist);
 127 }
 128
 129 void
 130 mozilla_embed_persist_cancelled (MozillaEmbedPersist *persist)
 131 {
 132         g_signal_emit_by_name (persist, "cancelled");
 133         g_object_unref (persist);
 134 }
 135
 136 static void
 137 impl_cancel (EphyEmbedPersist *persist)
 138 {
 139         nsCOMPtr<nsIWebBrowserPersist> bpersist =
 140                 MOZILLA_EMBED_PERSIST (persist)->priv->mPersist;
 141         nsCOMPtr<nsICancelable> cancelable (do_QueryInterface (bpersist));
 142         if (cancelable)
 143         {
 144                 cancelable->Cancel (NS_BINDING_ABORTED);
 145         }
 146
 147         g_object_unref (persist);
 148 }
 149
 150 static gboolean
 151 impl_save (EphyEmbedPersist *persist)
 152 {
 153         nsresult rv;
 154         char *filename;
 155         char *uri;
 156         gint64 max_size;
 157         EphyEmbed *embed;
 158         EphyEmbedPersistFlags flags;
 159         EphyEmbedSingle *single;
 160
 161         single = EPHY_EMBED_SINGLE (ephy_embed_shell_get_embed_single (embed_shell));
 162
 163         g_object_ref (persist);
 164
 165         g_object_get (persist,
 166                       "source", &uri,
 167                       "dest", &filename,
 168                       "flags", &flags,
 169                       "embed", &embed,
 170                       "max_size", &max_size,
 171                       (char *) NULL);
 172
 173         g_return_val_if_fail (!(flags & EPHY_EMBED_PERSIST_COPY_PAGE)
 174                               || embed != NULL, FALSE);
 175
 176         EphyBrowser *browser = NULL;
 177         if (embed)
 178         {
 179                 browser = (EphyBrowser *) _mozilla_embed_get_ephy_browser (MOZILLA_EMBED(embed));
 180
 181                 g_object_unref (embed);
 182
 183                 NS_ENSURE_TRUE (browser, FALSE);
 184         }
 185         /* we must have one of uri or browser */
 186         g_assert (browser != NULL || uri != NULL);
 187
 188         /* Get the uri to save to */
 189         nsCOMPtr<nsIURI> inURI;
 190         if (uri)
 191         {
 192                 /* FIXME: origin charset!! */
 193                 rv = EphyUtils::NewURI (getter_AddRefs(inURI), nsCString(uri));
 194                 NS_ENSURE_SUCCESS (rv, FALSE);
 195         }
 196         else
 197         {
 198                 rv = browser->GetDocumentURI (getter_AddRefs (inURI));
 199                 NS_ENSURE_SUCCESS (rv, FALSE);
 200         }
 201
 202         /* Get post data */
 203         nsCOMPtr<nsIInputStream> postData;
 204         /* FIXME: don't do this on COPY_PAGE to ensure we don't end up reposting? */
 205         if (browser)
 206         {
 207                 PRInt32 sindex;
 208
 209                 nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(browser->mWebBrowser));
 210                 nsCOMPtr<nsISHistory> sessionHistory;
 211                 webNav->GetSessionHistory(getter_AddRefs(sessionHistory));
 212                 nsCOMPtr<nsIHistoryEntry> entry;
 213                 sessionHistory->GetIndex(&sindex);
 214                 sessionHistory->GetEntryAtIndex(sindex, PR_FALSE, getter_AddRefs(entry));
 215                 nsCOMPtr<nsISHEntry> shEntry(do_QueryInterface(entry));
 216                 if (shEntry)
 217                 {
 218                         shEntry->GetPostData(getter_AddRefs(postData));
 219                 }
 220         }
 221
 222         /* Get the DOM document if a uri is not specified */
 223         nsCOMPtr<nsIDOMDocument> DOMDocument;
 224         if (!uri)
 225         {
 226                 if (flags & EPHY_EMBED_PERSIST_MAINDOC)
 227                 {
 228                         browser->GetDocument (getter_AddRefs(DOMDocument));
 229                 }
 230                 else
 231                 {
 232                         browser->GetTargetDocument (getter_AddRefs(DOMDocument));
 233                 }
 234                 NS_ENSURE_TRUE (DOMDocument, FALSE);
 235         }
 236
 237
 238         /* Get the current page descriptor */
 239         nsCOMPtr<nsISupports> cacheDescriptor;
 240         if (browser)
 241         {
 242                 browser->GetPageDescriptor(getter_AddRefs (cacheDescriptor));
 243         }
 244
 245         /* Try to get a descriptor from the cache session */
 246         /* FIXME: what about https?? */
 247         PRBool isHttp = PR_FALSE, isHttps = PR_FALSE;
 248         if (!cacheDescriptor &&
 249             (flags & EPHY_EMBED_PERSIST_FROM_CACHE) &&
 250             inURI &&
 251             ((NS_SUCCEEDED (inURI->SchemeIs ("http", &isHttp)) && isHttp) ||
 252              (NS_SUCCEEDED (inURI->SchemeIs ("https", &isHttps)) && isHttps )))
 253         {
 254                 nsCOMPtr<nsICacheService> cacheService
 255                                 (do_GetService(NS_CACHESERVICE_CONTRACTID));
 256                 if (cacheService)
 257                 {
 258                         nsCOMPtr<nsICacheSession> cacheSession;
 259                         rv = cacheService->CreateSession ("HTTP",
 260                                                           nsICache::STORE_ANYWHERE,
 261                                                           PR_TRUE,
 262                                                           getter_AddRefs (cacheSession));
 263                         if (NS_SUCCEEDED (rv) && cacheSession)
 264                         {
 265                                 nsCOMPtr<nsICacheEntryDescriptor> descriptor;
 266
 267                                 nsCString spec;
 268                                 inURI->GetSpec (spec);
 269
 270                                 rv = cacheSession->OpenCacheEntry
 271                                         (spec,
 272                                          nsICache::ACCESS_READ,
 273                                          PR_FALSE, getter_AddRefs (descriptor));
 274
 275                                 cacheDescriptor = do_QueryInterface (descriptor);
 276
 277                                 LOG ("Getting cache descriptor for '%s' rv=%x", spec.get(), rv);
 278                         }
 279                 }
 280         }
 281
 282         LOG ("Cache descriptor %p", cacheDescriptor.get());
 283
 284         /* if we have COPY_PAGE, we *need* to have a page descriptor, else we'll re-fetch
 285          * the page, which will possibly give a different page than the original which we
 286          * need for view source
 287          */
 288         NS_ENSURE_TRUE (!(flags & EPHY_EMBED_PERSIST_COPY_PAGE) || cacheDescriptor, FALSE);
 289
 290         if (filename == NULL || filename[0] == '\0')
 291         {
 292                 /* Get a temp filename to save to */
 293                 char *tmp_filename, *base;
 294                 base = g_build_filename (g_get_tmp_dir (), "sav-XXXXXX", (char *) NULL);
 295                 tmp_filename = ephy_file_tmp_filename (base, "html");
 296                 g_free (base);
 297                 if (tmp_filename == NULL) return FALSE;
 298
 299                 nsCOMPtr<nsILocalFile> tmpFile = do_CreateInstance (NS_LOCAL_FILE_CONTRACTID);
 300                 NS_ENSURE_TRUE (tmpFile, FALSE);
 301
 302                 tmpFile->InitWithNativePath (nsCString (tmp_filename));
 303                 g_free (tmp_filename);
 304
 305                 /* Create an header sniffer and do the save */
 306                 nsCOMPtr<nsIWebBrowserPersist> webPersist =
 307                         MOZILLA_EMBED_PERSIST (persist)->priv->mPersist;
 308                 NS_ENSURE_TRUE (webPersist, FALSE);
 309
 310                 EphyHeaderSniffer* sniffer = new EphyHeaderSniffer
 311                         (webPersist, MOZILLA_EMBED_PERSIST (persist),
 312                          tmpFile, inURI, DOMDocument, postData, single);
 313                 if (!sniffer) return FALSE;
 314
 315                 webPersist->SetProgressListener(sniffer);
 316                 rv = webPersist->SaveURI(inURI, cacheDescriptor, nsnull /* FIXME: Referrer */, nsnull, nsnull, tmpFile);
 317                 if (NS_FAILED (rv)) return FALSE;
 318         }
 319         else
 320         {
 321                 /* Filename to save to */
 322                 nsCOMPtr<nsILocalFile> destFile;
 323                 NS_NewNativeLocalFile (nsCString(filename),
 324                                        PR_TRUE, getter_AddRefs(destFile));
 325                 NS_ENSURE_TRUE (destFile, FALSE);
 326
 327                 rv =  InitiateMozillaDownload (DOMDocument, inURI, destFile,
 328                                                nsnull, inURI, MOZILLA_EMBED_PERSIST (persist),
 329                                                postData, cacheDescriptor, max_size);
 330                 if (NS_FAILED (rv)) return FALSE;
 331         }
 332
 333         g_free (uri);
 334         g_free (filename);
 335
 336         return TRUE;
 337 }
 338
 339 static char *
 340 impl_to_string (EphyEmbedPersist *persist)
 341 {
 342         EphyEmbed *embed;
 343         nsCOMPtr<nsIDOMDocument> DOMDocument;
 344         EphyEmbedPersistFlags flags;
 345         EphyBrowser *browser;
 346         nsresult rv = NS_OK;
 347
 348         g_object_ref (persist);
 349
 350         g_object_get (persist,
 351                       "flags", &flags,
 352                       "embed", &embed,
 353                       (char *) NULL);
 354         g_object_unref (persist);
 355         g_return_val_if_fail (embed != NULL, NULL);
 356
 357         browser = (EphyBrowser *) _mozilla_embed_get_ephy_browser (MOZILLA_EMBED(embed));
 358         g_return_val_if_fail (browser != NULL, NULL);
 359
 360         if (flags & EPHY_EMBED_PERSIST_MAINDOC)
 361         {
 362                 rv = browser->GetDocument (getter_AddRefs(DOMDocument));
 363         }
 364         else
 365         {
 366                 rv = browser->GetTargetDocument (getter_AddRefs(DOMDocument));
 367         }
 368
 369         nsCString cOutString;
 370         nsCOMPtr<nsIDOMNode> node = do_QueryInterface(DOMDocument);
 371         if (node)
 372         {
 373                 nsString outString;
 374                 nsCOMPtr<nsIDOMSerializer> serializer;
 375                 serializer = do_CreateInstance(NS_XMLSERIALIZER_CONTRACTID, &rv);
 376                 if (serializer)
 377                 {
 378                         serializer->SerializeToString(node, outString);
 379
 380                         NS_UTF16ToCString (outString, NS_CSTRING_ENCODING_UTF8, cOutString);
 381                 }
 382         }
 383
 384         g_object_unref (embed);
 385
 386         return g_strdup (cOutString.get());
 387 }
 388
 389 static GObject *
 390 mozilla_embed_persist_constructor (GType type, guint n_construct_properties,
 391                                    GObjectConstructParam *construct_params)
 392 {
 393         /* this will ensure that mozilla is started up */
 394         ephy_embed_shell_get_embed_single (embed_shell);
 395
 396         return parent_class->constructor (type, n_construct_properties,
 397                                           construct_params);
 398 }
 399
 400 static void
 401 mozilla_embed_persist_class_init (MozillaEmbedPersistClass *klass)
 402 {
 403         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 404         EphyEmbedPersistClass *persist_class = EPHY_EMBED_PERSIST_CLASS (klass);
 405
 406         parent_class = (GObjectClass *) g_type_class_peek_parent (klass);
 407
 408         object_class->finalize = mozilla_embed_persist_finalize;
 409         object_class->constructor = mozilla_embed_persist_constructor;
 410
 411         persist_class->save = impl_save;
 412         persist_class->cancel = impl_cancel;
 413         persist_class->to_string = impl_to_string;
 414
 415         g_type_class_add_private (object_class, sizeof(MozillaEmbedPersistPrivate));
 416 }