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

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* 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/. */

#include "mozilla/dom/Element.h"

#include "mozilla/dom/TabParent.h"

#include "mozilla/Preferences.h"

#include "mozilla/Unused.h"

#include "nsIContent.h"

#include "nsIDocument.h"

#include "nsIDOMWindow.h"

#include "nsIPrintingPromptService.h"

#include "nsIPrintProgressParams.h"

#include "nsIPrintSettingsService.h"

#include "nsIServiceManager.h"

#include "nsServiceManagerUtils.h"

#include "nsIWebProgressListener.h"

#include "PrintingParent.h"

#include "PrintDataUtils.h"

#include "PrintProgressDialogParent.h"

#include "PrintSettingsDialogParent.h"

#include "mozilla/layout/RemotePrintJobParent.h"

using namespace mozilla;

using namespace mozilla::dom;

using namespace mozilla::layout;

namespace mozilla {

namespace embedding {

mozilla::ipc::IPCResult

PrintingParent::RecvShowProgress(PBrowserParent* parent,

                                 PPrintProgressDialogParent* printProgressDialog,

                                 PRemotePrintJobParent* remotePrintJob,

                                 const bool& isForPrinting)

{

  bool notifyOnOpen = false;

  nsCOMPtr<nsPIDOMWindowOuter> parentWin = DOMWindowFromBrowserParent(parent);

  nsCOMPtr<nsIPrintingPromptService> pps(do_GetService("@mozilla.org/embedcomp/printingprompt-service;1"));

  PrintProgressDialogParent* dialogParent =

    static_cast<PrintProgressDialogParent*>(printProgressDialog);

  nsCOMPtr<nsIObserver> observer = do_QueryInterface(dialogParent);

  nsCOMPtr<nsIWebProgressListener> printProgressListener;

  nsCOMPtr<nsIPrintProgressParams> printProgressParams;

  nsresult rv = NS_ERROR_INVALID_ARG;

  if (parentWin && pps) {

    rv = pps->ShowProgress(parentWin, nullptr, nullptr, observer,

                           isForPrinting,

                           getter_AddRefs(printProgressListener),

                           getter_AddRefs(printProgressParams),

                           &notifyOnOpen);

  }

  if (NS_SUCCEEDED(rv)) {

    if (remotePrintJob) {

      // If we have a RemotePrintJob use that as a more general forwarder for

      // print progress listeners.

      static_cast<RemotePrintJobParent*>(remotePrintJob)

          ->RegisterListener(printProgressListener);

    } else {

      dialogParent->SetWebProgressListener(printProgressListener);

    }

    dialogParent->SetPrintProgressParams(printProgressParams);

  }

  // NOTE: If we aren't going to observe an event on our observer, we need to

  // fake one. This takes the form of sending the SendDialogOpened message. This

  // is safe because the child process proxy will always return `true` for

  // notifyOnOpen, as the request will always be async when performed across

  // process boundaries.

  //

  // We can pass nullptr for all of the arguments, as all consumers of this

  // observer don't care about the subject, topic, or data.

  //

  // If notifyOnOpen is true, then the ShowProgress call will handle notifying

  // our observer for us.

  if (!notifyOnOpen) {

    observer->Observe(nullptr, nullptr, nullptr);

  }

  return IPC_OK();

}

nsresult

PrintingParent::ShowPrintDialog(PBrowserParent* aParent,

                                const PrintData& aData,

                                PrintData* aResult)

{

  // If aParent is null this call is just being used to get print settings from

  // the printer for print preview.

  bool isPrintPreview = !aParent;

  nsCOMPtr<nsPIDOMWindowOuter> parentWin;

  if (aParent) {

    parentWin = DOMWindowFromBrowserParent(aParent);

    if (!parentWin) {

      return NS_ERROR_FAILURE;

    }

  }

  nsCOMPtr<nsIPrintingPromptService> pps(do_GetService("@mozilla.org/embedcomp/printingprompt-service;1"));

  if (!pps) {

    return NS_ERROR_FAILURE;

  }

  // The initSettings we got can be wrapped using

  // PrintDataUtils' MockWebBrowserPrint, which implements enough of

  // nsIWebBrowserPrint to keep the dialogs happy.

  nsCOMPtr<nsIWebBrowserPrint> wbp = new MockWebBrowserPrint(aData);

  // Use the existing RemotePrintJob and its settings, if we have one, to make

  // sure they stay current.

  RemotePrintJobParent* remotePrintJob =

    static_cast<RemotePrintJobParent*>(aData.remotePrintJobParent());

  nsCOMPtr<nsIPrintSettings> settings;

  nsresult rv;

  if (remotePrintJob) {

    settings = remotePrintJob->GetPrintSettings();

  } else {

    rv = mPrintSettingsSvc->GetNewPrintSettings(getter_AddRefs(settings));

    NS_ENSURE_SUCCESS(rv, rv);

  }

  // We only want to use the print silently setting from the parent.

  bool printSilently;

  rv = settings->GetPrintSilent(&printSilently);

  NS_ENSURE_SUCCESS(rv, rv);

  rv = mPrintSettingsSvc->DeserializeToPrintSettings(aData, settings);

  NS_ENSURE_SUCCESS(rv, rv);

  rv = settings->SetPrintSilent(printSilently);

  NS_ENSURE_SUCCESS(rv, rv);

  nsString printerName;

  settings->GetPrinterName(printerName);

#ifdef MOZ_X11

  // Requesting the default printer name on Linux has been removed in the child,

  // because it was causing a sandbox violation (see Bug 1329216).

  // If no printer name is set at this point, use the print settings service

  // to get the default printer name, unless we're printing to file.

  bool printToFile = false;

  MOZ_ALWAYS_SUCCEEDS(settings->GetPrintToFile(&printToFile));

  if (!printToFile && printerName.IsEmpty()) {

    mPrintSettingsSvc->GetDefaultPrinterName(printerName);

    settings->SetPrinterName(printerName);

  }

  mPrintSettingsSvc->InitPrintSettingsFromPrinter(printerName, settings);

#endif

  // If this is for print preview or we are printing silently then we just need

  // to initialize the print settings with anything specific from the printer.

  if (isPrintPreview || printSilently ||

      Preferences::GetBool("print.always_print_silent", printSilently)) {

    settings->SetIsInitializedFromPrinter(false);

    mPrintSettingsSvc->InitPrintSettingsFromPrinter(printerName, settings);

  } else {

    rv = pps->ShowPrintDialog(parentWin, wbp, settings);

    NS_ENSURE_SUCCESS(rv, rv);

  }

  if (isPrintPreview) {

    // For print preview we don't want a RemotePrintJob just the settings.

    rv = mPrintSettingsSvc->SerializeToPrintData(settings, nullptr, aResult);

  } else {

    rv = SerializeAndEnsureRemotePrintJob(settings, nullptr, remotePrintJob,

                                          aResult);

  }

  return rv;

}

mozilla::ipc::IPCResult

PrintingParent::RecvShowPrintDialog(PPrintSettingsDialogParent* aDialog,

                                    PBrowserParent* aParent,

                                    const PrintData& aData)

{

  PrintData resultData;

  nsresult rv = ShowPrintDialog(aParent, aData, &resultData);

  // The child has been spinning an event loop while waiting

  // to hear about the print settings. We return the results

  // with an async message which frees the child process from

  // its nested event loop.

  if (NS_FAILED(rv)) {

    mozilla::Unused << PPrintingParent::PPrintSettingsDialogParent::Send__delete__(aDialog, rv);

  } else {

    mozilla::Unused << PPrintingParent::PPrintSettingsDialogParent::Send__delete__(aDialog, resultData);

  }

  return IPC_OK();

}

mozilla::ipc::IPCResult

PrintingParent::RecvSavePrintSettings(const PrintData& aData,

                                      const bool& aUsePrinterNamePrefix,

                                      const uint32_t& aFlags,

                                      nsresult* aResult)

{

  nsCOMPtr<nsIPrintSettings> settings;

  *aResult = mPrintSettingsSvc->GetNewPrintSettings(getter_AddRefs(settings));

  NS_ENSURE_SUCCESS(*aResult, IPC_OK());

  *aResult = mPrintSettingsSvc->DeserializeToPrintSettings(aData, settings);

  NS_ENSURE_SUCCESS(*aResult, IPC_OK());

  *aResult = mPrintSettingsSvc->SavePrintSettingsToPrefs(settings,

                                                        aUsePrinterNamePrefix,

                                                        aFlags);

  return IPC_OK();

}

PPrintProgressDialogParent*

PrintingParent::AllocPPrintProgressDialogParent()

{

  PrintProgressDialogParent* actor = new PrintProgressDialogParent();

  NS_ADDREF(actor); // De-ref'd in the __delete__ handler for

                    // PrintProgressDialogParent.

  return actor;

}

bool

PrintingParent::DeallocPPrintProgressDialogParent(PPrintProgressDialogParent* doomed)

{

  // We can't just delete the PrintProgressDialogParent since somebody might

  // still be holding a reference to it as nsIObserver, so just decrement the

  // refcount instead.

  PrintProgressDialogParent* actor = static_cast<PrintProgressDialogParent*>(doomed);

  NS_RELEASE(actor);

  return true;

}

PPrintSettingsDialogParent*

PrintingParent::AllocPPrintSettingsDialogParent()

{

  return new PrintSettingsDialogParent();

}

bool

PrintingParent::DeallocPPrintSettingsDialogParent(PPrintSettingsDialogParent* aDoomed)

{

  delete aDoomed;

  return true;

}

PRemotePrintJobParent*

PrintingParent::AllocPRemotePrintJobParent()

{

  MOZ_ASSERT_UNREACHABLE("No default constructors for implementations.");

  return nullptr;

}

bool

PrintingParent::DeallocPRemotePrintJobParent(PRemotePrintJobParent* aDoomed)

{

  delete aDoomed;

  return true;

}

void

PrintingParent::ActorDestroy(ActorDestroyReason aWhy)

{

}

nsPIDOMWindowOuter*

PrintingParent::DOMWindowFromBrowserParent(PBrowserParent* parent)

{

  if (!parent) {

    return nullptr;

  }

  TabParent* tabParent = TabParent::GetFrom(parent);

  if (!tabParent) {

    return nullptr;

  }

  nsCOMPtr<Element> frameElement = tabParent->GetOwnerElement();

  if (!frameElement) {

    return nullptr;

  }

  nsCOMPtr<nsIContent> frame(do_QueryInterface(frameElement));

  if (!frame) {

    return nullptr;

  }

  nsCOMPtr<nsPIDOMWindowOuter> parentWin = frame->OwnerDoc()->GetWindow();

  if (!parentWin) {

    return nullptr;

  }

  return parentWin;

}

nsresult

PrintingParent::SerializeAndEnsureRemotePrintJob(

  nsIPrintSettings* aPrintSettings, nsIWebProgressListener* aListener,

  layout::RemotePrintJobParent* aRemotePrintJob, PrintData* aPrintData)

{

  MOZ_ASSERT(aPrintData);

  nsresult rv;

  nsCOMPtr<nsIPrintSettings> printSettings;

  if (aPrintSettings) {

    printSettings = aPrintSettings;

  } else {

    rv = mPrintSettingsSvc->GetNewPrintSettings(getter_AddRefs(printSettings));

    if (NS_WARN_IF(NS_FAILED(rv))) {

      return rv;

    }

  }

  rv = mPrintSettingsSvc->SerializeToPrintData(printSettings, nullptr,

                                               aPrintData);

  if (NS_WARN_IF(NS_FAILED(rv))) {

    return rv;

  }

  RemotePrintJobParent* remotePrintJob;

  if (aRemotePrintJob) {

    remotePrintJob = aRemotePrintJob;

    aPrintData->remotePrintJobParent() = remotePrintJob;

  } else {

    remotePrintJob = new RemotePrintJobParent(aPrintSettings);

    aPrintData->remotePrintJobParent() =

      SendPRemotePrintJobConstructor(remotePrintJob);

  }

  if (aListener) {

    remotePrintJob->RegisterListener(aListener);

  }

  return NS_OK;

}

PrintingParent::PrintingParent()

{

  mPrintSettingsSvc =

    do_GetService("@mozilla.org/gfx/printsettings-service;1");

  MOZ_ASSERT(mPrintSettingsSvc);

}

PrintingParent::~PrintingParent()

{

}

} // namespace embedding

} // namespace mozilla