Include printing sources and enable printing for desktop platforms.

Also adds Qt specific core classes for printing as well as adding
printing related objects to the web engine context and including
the printing sources in the builds for the desktop platforms.

Also updates src/3rdparty submodule SHA-1.

Change-Id: I9c2631c59f63571c0840d838077e66122bacc741
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@theqtcompany.com>

18 files changed, 1673 insertions, 3 deletions

diff --git a/src/3rdparty b/src/3rdparty
-Subproject f8c56902fad36d8b43902d81ddc585e543c31b4
+Subproject df7c5f41e9f7e6a1382706e99bd78c4b7e3d120
diff --git a/src/core/chrome_qt.gyp b/src/core/chrome_qt.gyp
index 626691db4..d7e6cc2e9 100644
--- a/src/core/chrome_qt.gyp
+++ b/src/core/chrome_qt.gyp
@@ -118,7 +118,29 @@
                 '<(DEPTH)/chrome/renderer/spellchecker/platform_spelling_engine.h',
               ],
             }],
-          ]
+          ],
+        }],
+        ['enable_basic_printing==1 or enable_print_preview==1', {
+          'sources': [
+            '<(DEPTH)/chrome/browser/printing/print_job.cc',
+            '<(DEPTH)/chrome/browser/printing/print_job.h',
+            '<(DEPTH)/chrome/browser/printing/print_job_manager.cc',
+            '<(DEPTH)/chrome/browser/printing/print_job_manager.h',
+            '<(DEPTH)/chrome/browser/printing/print_job_worker.cc',
+            '<(DEPTH)/chrome/browser/printing/print_job_worker.h',
+            '<(DEPTH)/chrome/browser/printing/print_job_worker_owner.cc',
+            '<(DEPTH)/chrome/browser/printing/print_job_worker_owner.h',
+            '<(DEPTH)/chrome/browser/printing/printer_query.cc',
+            '<(DEPTH)/chrome/browser/printing/printer_query.h',
+            '<(DEPTH)/extensions/browser/notification_types.h',
+            '<(DEPTH)/extensions/browser/notification_types.cc',
+          ],
+          'dependencies': [
+            '<(chromium_src_dir)/third_party/mojo/mojo_public.gyp:mojo_cpp_bindings',
+          ],
+          'include_dirs': [
+            '<(chromium_src_dir)/extensions',
+          ],
         }],
       ],
     },
diff --git a/src/core/config/common.pri b/src/core/config/common.pri
index c5921a573..96506cd37 100644
--- a/src/core/config/common.pri
+++ b/src/core/config/common.pri
@@ -5,6 +5,6 @@ GYP_CONFIG += use_qt=1
 # We do not want to ship more external binary blobs, so let v8 embed its startup data.
 GYP_CONFIG += v8_use_external_startup_data=0
 # Disable printing since we don't support it yet
-GYP_CONFIG += enable_basic_printing=0 enable_print_preview=0
+GYP_CONFIG += enable_basic_printing=1 enable_print_preview=0
 # WebSpeech requires Google API keys and adds dependencies on speex and flac.
 GYP_CONFIG += enable_web_speech=0
diff --git a/src/core/config/embedded_linux.pri b/src/core/config/embedded_linux.pri
index 84db049cb..7cabf52ac 100644
--- a/src/core/config/embedded_linux.pri
+++ b/src/core/config/embedded_linux.pri
@@ -9,6 +9,7 @@ GYP_CONFIG += \
     embedded=1 \
     enable_autofill_dialog=0 \
     enable_automation=0 \
+    enable_basic_printing=0 \
     enable_captive_portal_detection=0 \
     enable_extensions=0 \
     enable_google_now=0 \
diff --git a/src/core/config/embedded_qnx.pri b/src/core/config/embedded_qnx.pri
index 34470d2d8..c05e8bb59 100644
--- a/src/core/config/embedded_qnx.pri
+++ b/src/core/config/embedded_qnx.pri
@@ -4,6 +4,7 @@ include(common.pri)
 
 GYP_CONFIG += \
     disable_nacl=1 \
+    enable_basic_printing=0 \
     enable_plugins=0 \
     enable_webrtc=0 \
     use_ash=0 \
diff --git a/src/core/content_browser_client_qt.cpp b/src/core/content_browser_client_qt.cpp
index 54430b81c..9e021dd6a 100644
--- a/src/core/content_browser_client_qt.cpp
+++ b/src/core/content_browser_client_qt.cpp
@@ -76,6 +76,9 @@
 #include "location_provider_qt.h"
 #endif
 #include "media_capture_devices_dispatcher.h"
+#if defined(ENABLE_BASIC_PRINTING)
+#include "printing_message_filter_qt.h"
+#endif // defined(ENABLE_BASIC_PRINTING)
 #include "resource_dispatcher_host_delegate_qt.h"
 #include "user_script_controller_host.h"
 #include "web_contents_delegate_qt.h"
@@ -364,6 +367,9 @@ void ContentBrowserClientQt::RenderProcessWillLaunch(content::RenderProcessHost*
 #if defined(ENABLE_SPELLCHECK)
     host->AddFilter(new SpellCheckMessageFilter(id));
 #endif
+#if defined(ENABLE_BASIC_PRINTING)
+    host->AddFilter(new PrintingMessageFilterQt(host->GetID()));
+#endif // defined(ENABLE_BASIC_PRINTING)
 }
 
 void ContentBrowserClientQt::ResourceDispatcherHostCreated()
diff --git a/src/core/print_view_manager_base_qt.cpp b/src/core/print_view_manager_base_qt.cpp
new file mode 100644
index 000000000..ea6345f94
--- /dev/null
+++ b/src/core/print_view_manager_base_qt.cpp
@@ -0,0 +1,520 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtWebEngine module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "print_view_manager_qt.h"
+
+#include "type_conversion.h"
+#include "web_engine_context.h"
+
+#include "base/single_thread_task_runner.h"
+#include "base/thread_task_runner_handle.h"
+#include "base/timer/timer.h"
+#include "base/values.h"
+#include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/printing/print_job.h"
+#include "chrome/browser/printing/print_job_manager.h"
+#include "chrome/browser/printing/printer_query.h"
+#include "components/printing/common/print_messages.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_types.h"
+#include "printing/pdf_metafile_skia.h"
+#include "printing/print_job_constants.h"
+#include "printing/printed_document.h"
+
+namespace QtWebEngineCore {
+
+PrintViewManagerBaseQt::~PrintViewManagerBaseQt()
+{
+}
+
+// PrintedPagesSource implementation.
+base::string16 PrintViewManagerBaseQt::RenderSourceName()
+{
+     return toString16(QLatin1String(""));
+}
+
+PrintViewManagerBaseQt::PrintViewManagerBaseQt(content::WebContents *contents)
+    : printing::PrintManager(contents)
+    , m_isInsideInnerMessageLoop(false)
+    , m_isExpectingFirstPage(false)
+    , m_didPrintingSucceed(false)
+    , m_printerQueriesQueue(WebEngineContext::current()->getPrintJobManager()->queue())
+{
+
+}
+
+void PrintViewManagerBaseQt::OnNotifyPrintJobEvent(
+    const printing::JobEventDetails& event_details) {
+  switch (event_details.type()) {
+    case printing::JobEventDetails::FAILED: {
+      TerminatePrintJob(true);
+
+      content::NotificationService::current()->Notify(
+          chrome::NOTIFICATION_PRINT_JOB_RELEASED,
+          content::Source<content::WebContents>(web_contents()),
+          content::NotificationService::NoDetails());
+      break;
+    }
+    case printing::JobEventDetails::USER_INIT_DONE:
+    case printing::JobEventDetails::DEFAULT_INIT_DONE:
+    case printing::JobEventDetails::USER_INIT_CANCELED: {
+      NOTREACHED();
+      break;
+    }
+    case printing::JobEventDetails::ALL_PAGES_REQUESTED: {
+      break;
+    }
+    case printing::JobEventDetails::NEW_DOC:
+    case printing::JobEventDetails::NEW_PAGE:
+    case printing::JobEventDetails::PAGE_DONE:
+    case printing::JobEventDetails::DOC_DONE: {
+      // Don't care about the actual printing process.
+      break;
+    }
+    case printing::JobEventDetails::JOB_DONE: {
+      // Printing is done, we don't need it anymore.
+      // print_job_->is_job_pending() may still be true, depending on the order
+      // of object registration.
+      m_didPrintingSucceed = true;
+      ReleasePrintJob();
+
+      content::NotificationService::current()->Notify(
+          chrome::NOTIFICATION_PRINT_JOB_RELEASED,
+          content::Source<content::WebContents>(web_contents()),
+          content::NotificationService::NoDetails());
+      break;
+    }
+    default: {
+      NOTREACHED();
+      break;
+    }
+  }
+}
+
+
+// content::WebContentsObserver implementation.
+// Cancels the print job.
+void PrintViewManagerBaseQt::NavigationStopped()
+{
+}
+
+// content::WebContentsObserver implementation.
+void PrintViewManagerBaseQt::DidStartLoading()
+{
+}
+
+// content::NotificationObserver implementation.
+void PrintViewManagerBaseQt::Observe(
+        int type,
+        const content::NotificationSource& source,
+        const content::NotificationDetails& details) {
+    switch (type) {
+    case chrome::NOTIFICATION_PRINT_JOB_EVENT:
+        OnNotifyPrintJobEvent(*content::Details<printing::JobEventDetails>(details).ptr());
+        break;
+    default:
+        NOTREACHED();
+        break;
+
+    }
+}
+    // Terminates or cancels the print job if one was pending.
+void PrintViewManagerBaseQt::RenderProcessGone(base::TerminationStatus status)
+{
+    PrintManager::RenderProcessGone(status);
+    ReleasePrinterQuery();
+
+    if (!m_printJob.get())
+      return;
+
+    scoped_refptr<printing::PrintedDocument> document(m_printJob->document());
+    if (document.get()) {
+      // If IsComplete() returns false, the document isn't completely rendered.
+      // Since our renderer is gone, there's nothing to do, cancel it. Otherwise,
+      // the print job may finish without problem.
+      TerminatePrintJob(!document->IsComplete());
+    }
+}
+
+void PrintViewManagerBaseQt::ReleasePrinterQuery() {
+  if (!cookie_)
+    return;
+
+  int cookie = cookie_;
+  cookie_ = 0;
+
+  printing::PrintJobManager* printJobManager =
+      WebEngineContext::current()->getPrintJobManager();
+  // May be NULL in tests.
+  if (!printJobManager)
+    return;
+
+  scoped_refptr<printing::PrinterQuery> printerQuery;
+  printerQuery = m_printerQueriesQueue->PopPrinterQuery(cookie);
+  if (!printerQuery.get())
+    return;
+  content::BrowserThread::PostTask(
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(&printing::PrinterQuery::StopWorker, printerQuery.get()));
+}
+
+
+// content::WebContentsObserver implementation.
+bool PrintViewManagerBaseQt::OnMessageReceived(const IPC::Message& message)
+{
+    bool handled = true;
+    IPC_BEGIN_MESSAGE_MAP(PrintViewManagerBaseQt, message)
+      IPC_MESSAGE_HANDLER(PrintHostMsg_DidPrintPage, OnDidPrintPage)
+      IPC_MESSAGE_HANDLER(PrintHostMsg_ShowInvalidPrinterSettingsError,
+                          OnShowInvalidPrinterSettingsError);
+      IPC_MESSAGE_UNHANDLED(handled = false)
+    IPC_END_MESSAGE_MAP()
+    return handled || PrintManager::OnMessageReceived(message);
+}
+
+void PrintViewManagerBaseQt::StopWorker(int documentCookie) {
+  if (documentCookie <= 0)
+    return;
+  scoped_refptr<printing::PrinterQuery> printer_query =
+      m_printerQueriesQueue->PopPrinterQuery(documentCookie);
+  if (printer_query.get()) {
+    content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
+                            base::Bind(&printing::PrinterQuery::StopWorker,
+                                       printer_query));
+  }
+}
+
+
+// IPC handlers
+void PrintViewManagerBaseQt::OnDidPrintPage(
+  const PrintHostMsg_DidPrintPage_Params& params) {
+  if (!OpportunisticallyCreatePrintJob(params.document_cookie))
+    return;
+
+  printing::PrintedDocument* document = m_printJob->document();
+  if (!document || params.document_cookie != document->cookie()) {
+    // Out of sync. It may happen since we are completely asynchronous. Old
+    // spurious messages can be received if one of the processes is overloaded.
+    return;
+  }
+
+#if defined(OS_MACOSX)
+  const bool metafile_must_be_valid = true;
+#else
+  const bool metafile_must_be_valid = m_isExpectingFirstPage;
+  m_isExpectingFirstPage = false;
+#endif
+
+  // Only used when |metafile_must_be_valid| is true.
+  scoped_ptr<base::SharedMemory> shared_buf;
+  if (metafile_must_be_valid) {
+    if (!base::SharedMemory::IsHandleValid(params.metafile_data_handle)) {
+      NOTREACHED() << "invalid memory handle";
+      web_contents()->Stop();
+      return;
+    }
+    shared_buf.reset(new base::SharedMemory(params.metafile_data_handle, true));
+    if (!shared_buf->Map(params.data_size)) {
+      NOTREACHED() << "couldn't map";
+      web_contents()->Stop();
+      return;
+    }
+  } else {
+    if (base::SharedMemory::IsHandleValid(params.metafile_data_handle)) {
+      NOTREACHED() << "unexpected valid memory handle";
+      web_contents()->Stop();
+      base::SharedMemory::CloseHandle(params.metafile_data_handle);
+      return;
+    }
+  }
+
+  scoped_ptr<printing::PdfMetafileSkia> metafile(new printing::PdfMetafileSkia);
+  if (metafile_must_be_valid) {
+    if (!metafile->InitFromData(shared_buf->memory(), params.data_size)) {
+      NOTREACHED() << "Invalid metafile header";
+      web_contents()->Stop();
+      return;
+    }
+  }
+
+#if defined(OS_WIN) && !defined(TOOLKIT_QT)
+  if (metafile_must_be_valid) {
+    scoped_refptr<base::RefCountedBytes> bytes = new base::RefCountedBytes(
+        reinterpret_cast<const unsigned char*>(shared_buf->memory()),
+        params.data_size);
+
+    document->DebugDumpData(bytes.get(), FILE_PATH_LITERAL(".pdf"));
+    m_printJob->StartPdfToEmfConversion(
+        bytes, params.page_size, params.content_area);
+  }
+#else
+  // Update the rendered document. It will send notifications to the listener.
+  document->SetPage(params.page_number,
+                    metafile.Pass(),
+#if defined(OS_WIN)
+                    1.0f, // shrink factor, needed on windows.
+#endif // defined(OS_WIN)
+                    params.page_size,
+                    params.content_area);
+
+  ShouldQuitFromInnerMessageLoop();
+#endif // defined (OS_WIN) && !defined(TOOLKIT_QT)
+}
+
+void PrintViewManagerBaseQt::OnShowInvalidPrinterSettingsError()
+{
+}
+
+bool PrintViewManagerBaseQt::CreateNewPrintJob(printing::PrintJobWorkerOwner* job) {
+  DCHECK(!m_isInsideInnerMessageLoop);
+
+  // Disconnect the current print_job_.
+  DisconnectFromCurrentPrintJob();
+
+  // We can't print if there is no renderer.
+  if (!web_contents()->GetRenderViewHost() ||
+      !web_contents()->GetRenderViewHost()->IsRenderViewLive()) {
+    return false;
+  }
+
+  // Ask the renderer to generate the print preview, create the print preview
+  // view and switch to it, initialize the printer and show the print dialog.
+  DCHECK(!m_printJob.get());
+  DCHECK(job);
+  if (!job)
+    return false;
+
+  m_printJob = new printing::PrintJob();
+  m_printJob->Initialize(job, this, number_pages_);
+  m_registrar.Add(this, chrome::NOTIFICATION_PRINT_JOB_EVENT,
+                 content::Source<printing::PrintJob>(m_printJob.get()));
+  m_didPrintingSucceed = false;
+  return true;
+}
+
+void PrintViewManagerBaseQt::DisconnectFromCurrentPrintJob() {
+  // Make sure all the necessary rendered page are done. Don't bother with the
+  // return value.
+  bool result = RenderAllMissingPagesNow();
+
+  // Verify that assertion.
+  if (m_printJob.get() &&
+      m_printJob->document() &&
+      !m_printJob->document()->IsComplete()) {
+    DCHECK(!result);
+    // That failed.
+    TerminatePrintJob(true);
+  } else {
+    // DO NOT wait for the job to finish.
+    ReleasePrintJob();
+  }
+#if !defined(OS_MACOSX)
+  m_isExpectingFirstPage = true;
+#endif
+}
+
+void PrintViewManagerBaseQt::PrintingDone(bool success) {
+  if (!m_printJob.get())
+    return;
+  Send(new PrintMsg_PrintingDone(routing_id(), success));
+}
+
+void PrintViewManagerBaseQt::TerminatePrintJob(bool cancel) {
+  if (!m_printJob.get())
+    return;
+
+  if (cancel) {
+    // We don't need the metafile data anymore because the printing is canceled.
+    m_printJob->Cancel();
+    m_isInsideInnerMessageLoop = false;
+  } else {
+    DCHECK(!m_isInsideInnerMessageLoop);
+    DCHECK(!m_printJob->document() || m_printJob->document()->IsComplete());
+
+    // WebContents is either dying or navigating elsewhere. We need to render
+    // all the pages in an hurry if a print job is still pending. This does the
+    // trick since it runs a blocking message loop:
+    m_printJob->Stop();
+  }
+  ReleasePrintJob();
+}
+
+bool PrintViewManagerBaseQt::OpportunisticallyCreatePrintJob(int cookie)
+{
+    if (m_printJob.get())
+      return true;
+
+    if (!cookie) {
+      // Out of sync. It may happens since we are completely asynchronous. Old
+      // spurious message can happen if one of the processes is overloaded.
+      return false;
+    }
+
+    // The job was initiated by a script. Time to get the corresponding worker
+    // thread.
+    scoped_refptr<printing::PrinterQuery> queued_query = m_printerQueriesQueue->PopPrinterQuery(cookie);
+    if (!queued_query.get()) {
+      NOTREACHED();
+      return false;
+    }
+
+    if (!CreateNewPrintJob(queued_query.get())) {
+      // Don't kill anything.
+      return false;
+    }
+
+    // Settings are already loaded. Go ahead. This will set
+    // print_job_->is_job_pending() to true.
+    m_printJob->StartPrinting();
+    return true;
+}
+
+void PrintViewManagerBaseQt::ReleasePrintJob() {
+  if (!m_printJob.get())
+    return;
+
+  PrintingDone(m_didPrintingSucceed);
+
+  m_registrar.Remove(this, chrome::NOTIFICATION_PRINT_JOB_EVENT,
+                    content::Source<printing::PrintJob>(m_printJob.get()));
+  m_printJob->DisconnectSource();
+  // Don't close the worker thread.
+  m_printJob = NULL;
+}
+
+// Requests the RenderView to render all the missing pages for the print job.
+// No-op if no print job is pending. Returns true if at least one page has
+// been requested to the renderer.
+bool PrintViewManagerBaseQt::RenderAllMissingPagesNow()
+{
+    if (!m_printJob.get() || !m_printJob->is_job_pending())
+      return false;
+
+    // We can't print if there is no renderer.
+    if (!web_contents() ||
+        !web_contents()->GetRenderViewHost() ||
+        !web_contents()->GetRenderViewHost()->IsRenderViewLive()) {
+      return false;
+    }
+
+    // Is the document already complete?
+    if (m_printJob->document() && m_printJob->document()->IsComplete()) {
+      m_didPrintingSucceed = true;
+      return true;
+    }
+
+    // WebContents is either dying or a second consecutive request to print
+    // happened before the first had time to finish. We need to render all the
+    // pages in an hurry if a print_job_ is still pending. No need to wait for it
+    // to actually spool the pages, only to have the renderer generate them. Run
+    // a message loop until we get our signal that the print job is satisfied.
+    // PrintJob will send a ALL_PAGES_REQUESTED after having received all the
+    // pages it needs. MessageLoop::current()->Quit() will be called as soon as
+    // print_job_->document()->IsComplete() is true on either ALL_PAGES_REQUESTED
+    // or in DidPrintPage(). The check is done in
+    // ShouldQuitFromInnerMessageLoop().
+    // BLOCKS until all the pages are received. (Need to enable recursive task)
+    if (!RunInnerMessageLoop()) {
+      // This function is always called from DisconnectFromCurrentPrintJob() so we
+      // know that the job will be stopped/canceled in any case.
+      return false;
+    }
+    return true;
+}
+
+bool PrintViewManagerBaseQt::RunInnerMessageLoop() {
+  // This value may actually be too low:
+  //
+  // - If we're looping because of printer settings initialization, the premise
+  // here is that some poor users have their print server away on a VPN over a
+  // slow connection. In this situation, the simple fact of opening the printer
+  // can be dead slow. On the other side, we don't want to die infinitely for a
+  // real network error. Give the printer 60 seconds to comply.
+  //
+  // - If we're looping because of renderer page generation, the renderer could
+  // be CPU bound, the page overly complex/large or the system just
+  // memory-bound.
+  static const int kPrinterSettingsTimeout = 60000;
+  base::OneShotTimer quit_timer;
+  quit_timer.Start(FROM_HERE,
+                   base::TimeDelta::FromMilliseconds(kPrinterSettingsTimeout),
+                   base::MessageLoop::current(), &base::MessageLoop::Quit);
+
+  m_isInsideInnerMessageLoop = true;
+
+  // Need to enable recursive task.
+  {
+    base::MessageLoop::ScopedNestableTaskAllower allow(
+        base::MessageLoop::current());
+    base::MessageLoop::current()->Run();
+  }
+
+  bool success = true;
+  if (m_isInsideInnerMessageLoop) {
+    // Ok we timed out. That's sad.
+    m_isInsideInnerMessageLoop = false;
+    success = false;
+  }
+
+  return success;
+}
+
+// Quits the current message loop if these conditions hold true: a document is
+// loaded and is complete and waiting_for_pages_to_be_rendered_ is true. This
+// function is called in DidPrintPage() or on ALL_PAGES_REQUESTED
+// notification. The inner message loop is created was created by
+// RenderAllMissingPagesNow().
+void PrintViewManagerBaseQt::ShouldQuitFromInnerMessageLoop()
+{
+    // Look at the reason.
+    DCHECK(m_printJob->document());
+    if (m_printJob->document() &&
+        m_printJob->document()->IsComplete() &&
+        m_isInsideInnerMessageLoop) {
+      // We are in a message loop created by RenderAllMissingPagesNow. Quit from
+      // it.
+      base::MessageLoop::current()->Quit();
+      m_isInsideInnerMessageLoop = false;
+    }
+}
+
+} // namespace QtWebEngineCore
diff --git a/src/core/print_view_manager_base_qt.h b/src/core/print_view_manager_base_qt.h
new file mode 100644
index 000000000..f1e001eee
--- /dev/null
+++ b/src/core/print_view_manager_base_qt.h
@@ -0,0 +1,150 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtWebEngine module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef PRINT_VIEW_MANAGER_BASE_QT_H
+#define PRINT_VIEW_MANAGER_BASE_QT_H
+
+#include "base/memory/ref_counted.h"
+#include "base/prefs/pref_member.h"
+#include "base/strings/string16.h"
+#include "components/printing/browser/print_manager.h"
+#include "content/public/browser/notification_observer.h"
+#include "content/public/browser/notification_registrar.h"
+#include "printing/printed_pages_source.h"
+
+struct PrintHostMsg_DidPrintPage_Params;
+
+namespace content {
+class RenderViewHost;
+}
+
+namespace printing {
+class JobEventDetails;
+class MetafilePlayer;
+class PrintJob;
+class PrintJobWorkerOwner;
+class PrintQueriesQueue;
+}
+
+namespace QtWebEngineCore {
+class PrintViewManagerBaseQt
+        : public content::NotificationObserver
+        , public printing::PrintManager
+        , public printing::PrintedPagesSource
+{
+public:
+    ~PrintViewManagerBaseQt() override;
+
+    // PrintedPagesSource implementation.
+    base::string16 RenderSourceName() override;
+
+protected:
+    explicit PrintViewManagerBaseQt(content::WebContents*);
+
+    // content::WebContentsObserver implementation.
+    // Cancels the print job.
+    void NavigationStopped() override;
+
+    // Terminates or cancels the print job if one was pending.
+    void RenderProcessGone(base::TerminationStatus status) override;
+
+    // content::WebContentsObserver implementation.
+    bool OnMessageReceived(const IPC::Message& message) override;
+
+    // IPC Message handlers.
+    void OnDidPrintPage(const PrintHostMsg_DidPrintPage_Params& params);
+    void OnShowInvalidPrinterSettingsError();
+
+    // Processes a NOTIFY_PRINT_JOB_EVENT notification.
+    void OnNotifyPrintJobEvent(const printing::JobEventDetails& event_details);
+
+    int number_pages_;  // Number of pages to print in the print job.
+    int cookie_;
+    scoped_ptr<base::DictionaryValue> m_printSettings;
+
+    // content::NotificationObserver implementation.
+    void Observe(int,
+                 const content::NotificationSource&,
+                 const content::NotificationDetails&) override;
+    void StopWorker(int document_cookie);
+
+    // In the case of Scripted Printing, where the renderer is controlling the
+    // control flow, print_job_ is initialized whenever possible. No-op is
+    // print_job_ is initialized.
+    bool OpportunisticallyCreatePrintJob(int cookie);
+
+    // Requests the RenderView to render all the missing pages for the print job.
+    // No-op if no print job is pending. Returns true if at least one page has
+    // been requested to the renderer.
+    bool RenderAllMissingPagesNow();
+
+    // Quits the current message loop if these conditions hold true: a document is
+    // loaded and is complete and waiting_for_pages_to_be_rendered_ is true. This
+    // function is called in DidPrintPage() or on ALL_PAGES_REQUESTED
+    // notification. The inner message loop is created was created by
+    // RenderAllMissingPagesNow().
+    void ShouldQuitFromInnerMessageLoop();
+
+    bool RunInnerMessageLoop();
+
+    void TerminatePrintJob(bool cancel);
+    void PrintingDone(bool success);
+    void DisconnectFromCurrentPrintJob();
+
+    bool CreateNewPrintJob(printing::PrintJobWorkerOwner* job);
+    void ReleasePrintJob();
+    void ReleasePrinterQuery();
+
+private:
+    content::NotificationRegistrar m_registrar;
+    scoped_refptr<printing::PrintJob> m_printJob;
+
+    bool m_isInsideInnerMessageLoop;
+    bool m_isExpectingFirstPage;
+    bool m_didPrintingSucceed;
+    scoped_refptr<printing::PrintQueriesQueue> m_printerQueriesQueue;
+    // content::WebContentsObserver implementation.
+    void DidStartLoading() override;
+    DISALLOW_COPY_AND_ASSIGN(PrintViewManagerBaseQt);
+};
+
+} // namespace QtWebEngineCore
+#endif // PRINT_VIEW_MANAGER_BASE_QT_H
+
diff --git a/src/core/print_view_manager_qt.cpp b/src/core/print_view_manager_qt.cpp
new file mode 100644
index 000000000..f9b9c9f29
--- /dev/null
+++ b/src/core/print_view_manager_qt.cpp
@@ -0,0 +1,254 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtWebEngine module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "print_view_manager_qt.h"
+
+#include "type_conversion.h"
+#include "web_engine_context.h"
+
+#include <QtGui/QPageLayout>
+#include <QtGui/QPageSize>
+
+#include "base/values.h"
+#include "chrome/browser/printing/print_job_manager.h"
+#include "chrome/browser/printing/printer_query.h"
+#include "components/printing/common/print_messages.h"
+#include "content/public/browser/browser_thread.h"
+#include "printing/pdf_metafile_skia.h"
+#include "printing/print_job_constants.h"
+
+DEFINE_WEB_CONTENTS_USER_DATA_KEY(QtWebEngineCore::PrintViewManagerQt);
+
+namespace {
+static int request_id = 0;
+static const qreal kMicronsToMillimeter = 1000.0f;
+
+static scoped_refptr<base::RefCountedBytes>
+GetDataFromHandle(base::SharedMemoryHandle handle, uint32 data_size) {
+    scoped_ptr<base::SharedMemory> shared_buf(
+                new base::SharedMemory(handle, true));
+
+    if (!shared_buf->Map(data_size)) {
+        NOTREACHED();
+        return NULL;
+    }
+
+    unsigned char* data = static_cast<unsigned char*>(shared_buf->memory());
+    std::vector<unsigned char> dataVector(data, data + data_size);
+    return base::RefCountedBytes::TakeVector(&dataVector);
+}
+
+// Write the PDF file to disk.
+static void SavePdfFile(scoped_refptr<base::RefCountedBytes> data,
+                        const base::FilePath& path,
+                        const base::Callback<void(bool)>& callback) {
+    DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
+    DCHECK_GT(data->size(), 0U);
+
+    printing::PdfMetafileSkia metafile;
+    metafile.InitFromData(static_cast<const void*>(data->front()), data->size());
+
+    base::File file(path,
+                    base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
+    bool ok = file.IsValid() && metafile.SaveTo(&file);
+
+    if (!callback.is_null()) {
+        content::BrowserThread::PostTask(content::BrowserThread::UI,
+                                         FROM_HERE,
+                                         base::Bind(callback, ok));
+    }
+}
+
+static void applyQPageLayoutSettingsToDictionary(const QPageLayout& pageLayout, base::DictionaryValue& print_settings)
+{
+    //Set page size attributes, chromium expects these in micrometers
+    QSizeF pageSizeInMilimeter = pageLayout.pageSize().size(QPageSize::Millimeter);
+    scoped_ptr<base::DictionaryValue> sizeDict(new base::DictionaryValue);
+    sizeDict->SetInteger(printing::kSettingMediaSizeWidthMicrons, pageSizeInMilimeter.width() * kMicronsToMillimeter);
+    sizeDict->SetInteger(printing::kSettingMediaSizeHeightMicrons, pageSizeInMilimeter.height() * kMicronsToMillimeter);
+    print_settings.Set(printing::kSettingMediaSize, sizeDict.Pass());
+
+    print_settings.SetBoolean(printing::kSettingLandscape, pageLayout.orientation() == QPageLayout::Landscape);
+
+    print_settings.SetInteger(printing::kPreviewRequestID, request_id++);
+    print_settings.SetBoolean(printing::kIsFirstRequest, request_id != 0);
+
+    // The following are standard settings that Chromium expects to be set.
+    print_settings.SetBoolean(printing::kSettingPrintToPDF, true);
+    print_settings.SetBoolean(printing::kSettingCloudPrintDialog, false);
+    print_settings.SetBoolean(printing::kSettingPrintWithPrivet, false);
+    print_settings.SetBoolean(printing::kSettingPrintWithExtension, false);
+
+    print_settings.SetBoolean(printing::kSettingGenerateDraftData, false);
+    print_settings.SetBoolean(printing::kSettingPreviewModifiable, false);
+    print_settings.SetInteger(printing::kSettingColor, printing::COLOR);
+    print_settings.SetInteger(printing::kSettingDuplexMode, printing::SIMPLEX);
+    print_settings.SetInteger(printing::kSettingDuplexMode, printing::UNKNOWN_DUPLEX_MODE);
+    print_settings.SetInteger(printing::kSettingCopies, 1);
+    print_settings.SetBoolean(printing::kSettingCollate, false);
+    print_settings.SetBoolean(printing::kSettingGenerateDraftData, false);
+    print_settings.SetBoolean(printing::kSettingPreviewModifiable, false);
+
+    print_settings.SetBoolean(printing::kSettingShouldPrintSelectionOnly, false);
+    print_settings.SetBoolean(printing::kSettingShouldPrintBackgrounds, false);
+    print_settings.SetBoolean(printing::kSettingHeaderFooterEnabled, false);
+    print_settings.SetString(printing::kSettingDeviceName, "");
+    print_settings.SetInteger(printing::kPreviewUIID, 12345678);
+}
+
+} // namespace
+
+namespace QtWebEngineCore {
+
+PrintViewManagerQt::~PrintViewManagerQt()
+{
+}
+
+#if defined(ENABLE_BASIC_PRINTING)
+bool PrintViewManagerQt::PrintToPDF(const QPageLayout &pageLayout, const QString &filePath)
+{
+    return PrintToPDFWithCallback(pageLayout, filePath, base::Callback<void(bool)>());
+}
+
+bool PrintViewManagerQt::PrintToPDFWithCallback(const QPageLayout &pageLayout, const QString &filePath, base::Callback<void(bool)> callback)
+{
+    // If there already is a pending print in progress, don't try starting another one.
+    if (m_printSettings)
+        return false;
+
+    m_printSettings.reset(new base::DictionaryValue());
+    applyQPageLayoutSettingsToDictionary(pageLayout, *m_printSettings);
+    m_pdfOutputPath = toFilePath(filePath);
+
+    return Send(new PrintMsg_InitiatePrintPreview(routing_id(), false));
+}
+#endif // defined(ENABLE_BASIC_PRINTING)
+
+// PrintedPagesSource implementation.
+base::string16 PrintViewManagerQt::RenderSourceName()
+{
+     return toString16(QLatin1String(""));
+}
+
+PrintViewManagerQt::PrintViewManagerQt(content::WebContents *contents)
+    : PrintViewManagerBaseQt(contents)
+{
+
+}
+
+// content::WebContentsObserver implementation.
+bool PrintViewManagerQt::OnMessageReceived(const IPC::Message& message)
+{
+    bool handled = true;
+    IPC_BEGIN_MESSAGE_MAP(PrintViewManagerQt, message)
+      IPC_MESSAGE_HANDLER(PrintHostMsg_DidShowPrintDialog, OnDidShowPrintDialog)
+      IPC_MESSAGE_HANDLER(PrintHostMsg_RequestPrintPreview,
+                                 OnRequestPrintPreview)
+      IPC_MESSAGE_HANDLER(PrintHostMsg_MetafileReadyForPrinting,
+                                 OnMetafileReadyForPrinting);
+      IPC_MESSAGE_UNHANDLED(handled = false)
+    IPC_END_MESSAGE_MAP()
+    return handled || PrintManager::OnMessageReceived(message);
+}
+
+void PrintViewManagerQt::resetPdfState()
+{
+    m_pdfOutputPath.clear();
+    m_pdfPrintCallback.Reset();
+    m_printSettings.reset();
+}
+
+// IPC handlers
+
+void PrintViewManagerQt::OnRequestPrintPreview(
+    const PrintHostMsg_RequestPrintPreview_Params& params)
+{
+    Send(new PrintMsg_PrintPreview(routing_id(), *m_printSettings));
+}
+
+void PrintViewManagerQt::OnMetafileReadyForPrinting(
+    const PrintHostMsg_DidPreviewDocument_Params& params)
+{
+    StopWorker(params.document_cookie);
+
+    scoped_refptr<base::RefCountedBytes> data_bytes =
+        GetDataFromHandle(params.metafile_data_handle, params.data_size);
+    if (!data_bytes || !data_bytes->size()) {
+      resetPdfState();
+      return;
+    }
+
+    // Create local copies so we can reset the state and take a new pdf print job.
+    base::Callback<void(bool)> pdf_print_callback = m_pdfPrintCallback;
+    base::FilePath pdfOutputPath = m_pdfOutputPath;
+
+    // Save the PDF file to disk and then execute the callback.
+    content::BrowserThread::PostTask(content::BrowserThread::FILE,
+        FROM_HERE,
+        base::Bind(&SavePdfFile, data_bytes, pdfOutputPath,
+                   pdf_print_callback));
+
+    resetPdfState();
+}
+
+void PrintViewManagerQt::OnDidShowPrintDialog()
+{
+}
+
+// content::WebContentsObserver implementation.
+void PrintViewManagerQt::DidStartLoading()
+{
+}
+
+// content::WebContentsObserver implementation.
+// Cancels the print job.
+void PrintViewManagerQt::NavigationStopped()
+{
+    resetPdfState();
+}
+
+void PrintViewManagerQt::RenderProcessGone(base::TerminationStatus status)
+{
+    PrintViewManagerBaseQt::RenderProcessGone(status);
+    resetPdfState();
+}
+
+
+} // namespace QtWebEngineCore
diff --git a/src/core/print_view_manager_qt.h b/src/core/print_view_manager_qt.h
new file mode 100644
index 000000000..6ef7ec754
--- /dev/null
+++ b/src/core/print_view_manager_qt.h
@@ -0,0 +1,126 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtWebEngine module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef PRINT_VIEW_MANAGER_QT_H
+#define PRINT_VIEW_MANAGER_QT_H
+
+#include "print_view_manager_base_qt.h"
+
+#include <QtWebEngineCore/qtwebenginecoreglobal.h>
+#include "base/memory/ref_counted.h"
+#include "base/prefs/pref_member.h"
+#include "base/strings/string16.h"
+#include "components/printing/browser/print_manager.h"
+#include "content/public/browser/notification_observer.h"
+#include "content/public/browser/notification_registrar.h"
+#include "content/public/browser/web_contents_user_data.h"
+#include "printing/printed_pages_source.h"
+
+struct PrintHostMsg_RequestPrintPreview_Params;
+struct PrintHostMsg_DidPreviewDocument_Params;
+
+namespace content {
+class RenderViewHost;
+}
+
+namespace printing {
+class JobEventDetails;
+class MetafilePlayer;
+class PrintJob;
+class PrintJobWorkerOwner;
+class PrintQueriesQueue;
+}
+
+QT_BEGIN_NAMESPACE
+class QPageLayout;
+class QString;
+QT_END_NAMESPACE
+
+namespace QtWebEngineCore {
+class PrintViewManagerQt
+        : PrintViewManagerBaseQt
+        , public content::WebContentsUserData<PrintViewManagerQt>
+{
+public:
+    ~PrintViewManagerQt() override;
+
+#if defined(ENABLE_BASIC_PRINTING)
+    // Method to print a page to a Pdf document with page size \a pageSize in location \a filePath.
+    bool PrintToPDF(const QPageLayout& pageLayout, const QString& filePath);
+    bool PrintToPDFWithCallback(const QPageLayout& pageLayout, const QString& filePath, base::Callback<void(bool)> callback);
+#endif  // ENABLE_BASIC_PRINTING
+
+    // PrintedPagesSource implementation.
+    base::string16 RenderSourceName() override;
+
+protected:
+    explicit PrintViewManagerQt(content::WebContents*);
+
+    // content::WebContentsObserver implementation.
+    // Cancels the print job.
+    void NavigationStopped() override;
+
+    // Terminates or cancels the print job if one was pending.
+    void RenderProcessGone(base::TerminationStatus status) override;
+
+    // content::WebContentsObserver implementation.
+    bool OnMessageReceived(const IPC::Message& message) override;
+
+    // IPC handlers
+    void OnDidShowPrintDialog();
+    void OnRequestPrintPreview(const PrintHostMsg_RequestPrintPreview_Params&);
+    void OnMetafileReadyForPrinting(const PrintHostMsg_DidPreviewDocument_Params& params);
+
+    base::FilePath m_pdfOutputPath;
+    base::Callback<void(bool)> m_pdfPrintCallback;
+
+private:
+    friend class content::WebContentsUserData<PrintViewManagerQt>;
+
+    void resetPdfState();
+
+    // content::WebContentsObserver implementation.
+    void DidStartLoading() override;
+    DISALLOW_COPY_AND_ASSIGN(PrintViewManagerQt);
+};
+
+} // namespace QtWebEngineCore
+#endif // PRINT_VIEW_MANAGER_QT_H
+
diff --git a/src/core/printing_message_filter_qt.cpp b/src/core/printing_message_filter_qt.cpp
new file mode 100644
index 000000000..b9955fbb4
--- /dev/null
+++ b/src/core/printing_message_filter_qt.cpp
@@ -0,0 +1,260 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtWebEngine module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "printing_message_filter_qt.h"
+
+#include "web_engine_context.h"
+
+#include <string>
+
+#include "base/bind.h"
+#include "chrome/browser/printing/print_job_manager.h"
+#include "chrome/browser/printing/printer_query.h"
+#include "components/printing/browser/print_manager_utils.h"
+#include "components/printing/common/print_messages.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/common/child_process_host.h"
+
+using content::BrowserThread;
+
+namespace QtWebEngineCore {
+
+PrintingMessageFilterQt::PrintingMessageFilterQt(int render_process_id)
+    : BrowserMessageFilter(PrintMsgStart),
+      render_process_id_(render_process_id),
+      queue_(WebEngineContext::current()->getPrintJobManager()->queue()) {
+  DCHECK(queue_.get());
+}
+
+PrintingMessageFilterQt::~PrintingMessageFilterQt() {
+}
+
+void PrintingMessageFilterQt::OverrideThreadForMessage(
+    const IPC::Message& message, BrowserThread::ID* thread) {
+}
+
+bool PrintingMessageFilterQt::OnMessageReceived(const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(PrintingMessageFilterQt, message)
+#if defined(OS_WIN)
+    IPC_MESSAGE_HANDLER(PrintHostMsg_DuplicateSection, OnDuplicateSection)
+#endif
+    IPC_MESSAGE_HANDLER(PrintHostMsg_IsPrintingEnabled, OnIsPrintingEnabled)
+    IPC_MESSAGE_HANDLER_DELAY_REPLY(PrintHostMsg_GetDefaultPrintSettings,
+                                    OnGetDefaultPrintSettings)
+    IPC_MESSAGE_HANDLER_DELAY_REPLY(PrintHostMsg_ScriptedPrint, OnScriptedPrint)
+    IPC_MESSAGE_HANDLER_DELAY_REPLY(PrintHostMsg_UpdatePrintSettings,
+                                    OnUpdatePrintSettings)
+    IPC_MESSAGE_HANDLER(PrintHostMsg_CheckForCancel, OnCheckForCancel)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+#if defined(OS_WIN)
+void PrintingMessageFilterQt::OnDuplicateSection(
+    base::SharedMemoryHandle renderer_handle,
+    base::SharedMemoryHandle* browser_handle) {
+  // Duplicate the handle in this process right now so the memory is kept alive
+  // (even if it is not mapped)
+  base::SharedMemory shared_buf(renderer_handle, true, PeerHandle());
+  shared_buf.GiveToProcess(base::GetCurrentProcessHandle(), browser_handle);
+}
+#endif
+
+void PrintingMessageFilterQt::OnIsPrintingEnabled(bool* is_enabled) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  *is_enabled = true;
+}
+
+void PrintingMessageFilterQt::OnGetDefaultPrintSettings(IPC::Message* reply_msg) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  scoped_refptr<printing::PrinterQuery> printer_query;
+
+  printer_query = queue_->PopPrinterQuery(0);
+  if (!printer_query.get()) {
+    printer_query =
+        queue_->CreatePrinterQuery(render_process_id_, reply_msg->routing_id());
+  }
+
+  // Loads default settings. This is asynchronous, only the IPC message sender
+  // will hang until the settings are retrieved.
+  printer_query->GetSettings(
+      printing::PrinterQuery::GetSettingsAskParam::DEFAULTS,
+      0,
+      false,
+      printing::DEFAULT_MARGINS,
+      false,
+      base::Bind(&PrintingMessageFilterQt::OnGetDefaultPrintSettingsReply,
+                 this,
+                 printer_query,
+                 reply_msg));
+}
+
+void PrintingMessageFilterQt::OnGetDefaultPrintSettingsReply(
+    scoped_refptr<printing::PrinterQuery> printer_query,
+    IPC::Message* reply_msg) {
+  PrintMsg_Print_Params params;
+  if (!printer_query.get() ||
+      printer_query->last_status() != printing::PrintingContext::OK) {
+    params.Reset();
+  } else {
+    RenderParamsFromPrintSettings(printer_query->settings(), &params);
+    params.document_cookie = printer_query->cookie();
+  }
+  PrintHostMsg_GetDefaultPrintSettings::WriteReplyParams(reply_msg, params);
+  Send(reply_msg);
+  // If printing was enabled.
+  if (printer_query.get()) {
+    // If user hasn't cancelled.
+    if (printer_query->cookie() && printer_query->settings().dpi()) {
+      queue_->QueuePrinterQuery(printer_query.get());
+    } else {
+      printer_query->StopWorker();
+    }
+  }
+}
+
+void PrintingMessageFilterQt::OnScriptedPrint(
+    const PrintHostMsg_ScriptedPrint_Params& params,
+    IPC::Message* reply_msg) {
+  scoped_refptr<printing::PrinterQuery> printer_query =
+      queue_->PopPrinterQuery(params.cookie);
+  if (!printer_query.get()) {
+    printer_query =
+        queue_->CreatePrinterQuery(render_process_id_, reply_msg->routing_id());
+  }
+  printer_query->GetSettings(
+      printing::PrinterQuery::GetSettingsAskParam::ASK_USER,
+      params.expected_pages_count,
+      params.has_selection,
+      params.margin_type,
+      params.is_scripted,
+      base::Bind(&PrintingMessageFilterQt::OnScriptedPrintReply,
+                 this,
+                 printer_query,
+                 reply_msg));
+}
+
+void PrintingMessageFilterQt::OnScriptedPrintReply(
+    scoped_refptr<printing::PrinterQuery> printer_query,
+    IPC::Message* reply_msg) {
+  PrintMsg_PrintPages_Params params;
+
+  if (printer_query->last_status() != printing::PrintingContext::OK ||
+      !printer_query->settings().dpi()) {
+    params.Reset();
+  } else {
+    RenderParamsFromPrintSettings(printer_query->settings(), &params.params);
+    params.params.document_cookie = printer_query->cookie();
+    params.pages = printing::PageRange::GetPages(printer_query->settings().ranges());
+  }
+  PrintHostMsg_ScriptedPrint::WriteReplyParams(reply_msg, params);
+  Send(reply_msg);
+  if (params.params.dpi && params.params.document_cookie) {
+    queue_->QueuePrinterQuery(printer_query.get());
+  } else {
+    printer_query->StopWorker();
+  }
+}
+
+void PrintingMessageFilterQt::OnUpdatePrintSettings(
+    int document_cookie, const base::DictionaryValue& job_settings,
+    IPC::Message* reply_msg) {
+  scoped_ptr<base::DictionaryValue> new_settings(job_settings.DeepCopy());
+
+  scoped_refptr<printing::PrinterQuery> printer_query;
+  printer_query = queue_->PopPrinterQuery(document_cookie);
+  if (!printer_query.get()) {
+    int host_id = render_process_id_;
+    int routing_id = reply_msg->routing_id();
+    if (!new_settings->GetInteger(printing::kPreviewInitiatorHostId,
+                                  &host_id) ||
+        !new_settings->GetInteger(printing::kPreviewInitiatorRoutingId,
+                                  &routing_id)) {
+      host_id = content::ChildProcessHost::kInvalidUniqueID;
+      routing_id = content::ChildProcessHost::kInvalidUniqueID;
+    }
+    printer_query = queue_->CreatePrinterQuery(host_id, routing_id);
+  }
+  printer_query->SetSettings(
+      new_settings.Pass(),
+      base::Bind(&PrintingMessageFilterQt::OnUpdatePrintSettingsReply, this,
+                 printer_query, reply_msg));
+}
+
+void PrintingMessageFilterQt::OnUpdatePrintSettingsReply(
+    scoped_refptr<printing::PrinterQuery> printer_query,
+    IPC::Message* reply_msg) {
+  PrintMsg_PrintPages_Params params;
+  if (!printer_query.get() ||
+      printer_query->last_status() != printing::PrintingContext::OK) {
+    params.Reset();
+  } else {
+    RenderParamsFromPrintSettings(printer_query->settings(), &params.params);
+    params.params.document_cookie = printer_query->cookie();
+    params.pages = printing::PageRange::GetPages(printer_query->settings().ranges());
+  }
+
+  PrintHostMsg_UpdatePrintSettings::WriteReplyParams(
+      reply_msg,
+      params,
+      printer_query.get() &&
+          (printer_query->last_status() == printing::PrintingContext::CANCEL));
+  Send(reply_msg);
+  // If user hasn't cancelled.
+  if (printer_query.get()) {
+    if (printer_query->cookie() && printer_query->settings().dpi()) {
+      queue_->QueuePrinterQuery(printer_query.get());
+    } else {
+      printer_query->StopWorker();
+    }
+  }
+}
+
+void PrintingMessageFilterQt::OnCheckForCancel(int32 preview_ui_id,
+                                             int preview_request_id,
+                                             bool* cancel) {
+  *cancel = false;
+}
+
+}  // namespace printing
diff --git a/src/core/printing_message_filter_qt.h b/src/core/printing_message_filter_qt.h
new file mode 100644
index 000000000..004e5b86a
--- /dev/null
+++ b/src/core/printing_message_filter_qt.h
@@ -0,0 +1,138 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtWebEngine module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef PRINTING_PRINTING_MESSAGE_FILTER_QT_H_
+#define PRINTING_PRINTING_MESSAGE_FILTER_QT_H_
+
+#include <string>
+
+#include "base/compiler_specific.h"
+#include "base/prefs/pref_member.h"
+#include "content/public/browser/browser_message_filter.h"
+
+#if defined(OS_WIN)
+#include "base/memory/shared_memory.h"
+#endif
+
+struct PrintHostMsg_ScriptedPrint_Params;
+
+namespace base {
+class DictionaryValue;
+class FilePath;
+}
+
+namespace content {
+class WebContents;
+}
+
+namespace printing {
+
+class PrintJobManager;
+class PrintQueriesQueue;
+class PrinterQuery;
+}
+
+namespace QtWebEngineCore {
+// This class filters out incoming printing related IPC messages for the
+// renderer process on the IPC thread.
+class PrintingMessageFilterQt : public content::BrowserMessageFilter {
+ public:
+  PrintingMessageFilterQt(int render_process_id);
+
+  // content::BrowserMessageFilter methods.
+  void OverrideThreadForMessage(const IPC::Message& message,
+                                content::BrowserThread::ID* thread) override;
+  bool OnMessageReceived(const IPC::Message& message) override;
+
+ private:
+  ~PrintingMessageFilterQt() override;
+
+#if defined(OS_WIN)
+  // Used to pass resulting EMF from renderer to browser in printing.
+  void OnDuplicateSection(base::SharedMemoryHandle renderer_handle,
+                          base::SharedMemoryHandle* browser_handle);
+#endif
+
+  // GetPrintSettingsForRenderView must be called via PostTask and
+  // base::Bind.  Collapse the settings-specific params into a
+  // struct to avoid running into issues with too many params
+  // to base::Bind.
+  struct GetPrintSettingsForRenderViewParams;
+
+  // Checks if printing is enabled.
+  void OnIsPrintingEnabled(bool* is_enabled);
+
+  // Get the default print setting.
+  void OnGetDefaultPrintSettings(IPC::Message* reply_msg);
+  void OnGetDefaultPrintSettingsReply(scoped_refptr<printing::PrinterQuery> printer_query,
+                                      IPC::Message* reply_msg);
+
+  // The renderer host have to show to the user the print dialog and returns
+  // the selected print settings. The task is handled by the print worker
+  // thread and the UI thread. The reply occurs on the IO thread.
+  void OnScriptedPrint(const PrintHostMsg_ScriptedPrint_Params& params,
+                       IPC::Message* reply_msg);
+  void OnScriptedPrintReply(scoped_refptr<printing::PrinterQuery> printer_query,
+                            IPC::Message* reply_msg);
+
+  // Modify the current print settings based on |job_settings|. The task is
+  // handled by the print worker thread and the UI thread. The reply occurs on
+  // the IO thread.
+  void OnUpdatePrintSettings(int document_cookie,
+                             const base::DictionaryValue& job_settings,
+                             IPC::Message* reply_msg);
+  void OnUpdatePrintSettingsReply(scoped_refptr<printing::PrinterQuery> printer_query,
+                                  IPC::Message* reply_msg);
+
+  // Check to see if print preview has been cancelled.
+  void OnCheckForCancel(int32 preview_ui_id,
+                        int preview_request_id,
+                        bool* cancel);
+
+  const int render_process_id_;
+
+  scoped_refptr<printing::PrintQueriesQueue> queue_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrintingMessageFilterQt);
+};
+
+}  // namespace printing
+
+#endif  // PRINTING_PRINTING_MESSAGE_FILTER_QT_H_
diff --git a/src/core/qtwebengine.gypi b/src/core/qtwebengine.gypi
index c4fcc4309..42bf43822 100644
--- a/src/core/qtwebengine.gypi
+++ b/src/core/qtwebengine.gypi
@@ -120,5 +120,22 @@
       ['OS=="mac"', {
         'xcode_settings': {'OTHER_LDFLAGS': ['-Wl,-ObjC']},
       }],
+      ['enable_basic_printing==1 or enable_print_preview==1', {
+        'dependencies': [
+          '<(chromium_src_dir)/components/components.gyp:printing_browser',
+          '<(chromium_src_dir)/components/components.gyp:printing_common',
+          '<(chromium_src_dir)/components/components.gyp:printing_renderer',
+        ],
+        'sources': [
+          'printing_message_filter_qt.cpp',
+          'print_view_manager_base_qt.cpp',
+          'print_view_manager_qt.cpp',
+          'printing_message_filter_qt.h',
+          'print_view_manager_base_qt.h',
+          'print_view_manager_qt.h',
+          'renderer/print_web_view_helper_delegate_qt.cpp',
+          'renderer/print_web_view_helper_delegate_qt.h',
+        ]
+      }],
     ],
 }
diff --git a/src/core/renderer/content_renderer_client_qt.cpp b/src/core/renderer/content_renderer_client_qt.cpp
index 36e4f83f1..77d93226c 100644
--- a/src/core/renderer/content_renderer_client_qt.cpp
+++ b/src/core/renderer/content_renderer_client_qt.cpp
@@ -50,6 +50,9 @@
 #endif
 #include "components/cdm/renderer/widevine_key_systems.h"
 #include "components/error_page/common/error_page_params.h"
+#if defined (ENABLE_BASIC_PRINTING)
+#include "components/printing/renderer/print_web_view_helper.h"
+#endif // if defined(ENABLE_BASIC_PRINTING)
 #include "components/visitedlink/renderer/visitedlink_slave.h"
 #include "components/web_cache/renderer/web_cache_render_process_observer.h"
 #include "content/public/renderer/render_frame.h"
@@ -65,6 +68,10 @@
 #include "content/public/common/web_preferences.h"
 
 #include "renderer/web_channel_ipc_transport.h"
+#if defined (ENABLE_BASIC_PRINTING)
+#include "renderer/print_web_view_helper_delegate_qt.h"
+#endif // if defined(ENABLE_BASIC_PRINTING)
+
 #include "renderer/render_frame_observer_qt.h"
 #include "renderer/render_view_observer_qt.h"
 #include "renderer/user_script_controller.h"
@@ -112,6 +119,13 @@ void ContentRendererClientQt::RenderViewCreated(content::RenderView* render_view
 #if defined(ENABLE_SPELLCHECK)
     new SpellCheckProvider(render_view, m_spellCheck.data());
 #endif
+
+#if defined(ENABLE_BASIC_PRINTING)
+    new printing::PrintWebViewHelper(
+        render_view,
+        scoped_ptr<printing::PrintWebViewHelper::Delegate>(
+            new PrintWebViewHelperDelegateQt()));
+#endif // defined(ENABLE_BASIC_PRINTING)
 }
 
 void ContentRendererClientQt::RenderFrameCreated(content::RenderFrame* render_frame)
diff --git a/src/core/renderer/print_web_view_helper_delegate_qt.cpp b/src/core/renderer/print_web_view_helper_delegate_qt.cpp
new file mode 100644
index 000000000..6d74685fe
--- /dev/null
+++ b/src/core/renderer/print_web_view_helper_delegate_qt.cpp
@@ -0,0 +1,72 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtWebEngine module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "print_web_view_helper_delegate_qt.h"
+
+#include "third_party/WebKit/public/web/WebElement.h"
+
+namespace QtWebEngineCore {
+PrintWebViewHelperDelegateQt::~PrintWebViewHelperDelegateQt()
+{
+
+}
+
+bool PrintWebViewHelperDelegateQt::CancelPrerender(content::RenderView* render_view,
+                                                   int routing_id)
+{
+    return true;
+}
+
+blink::WebElement PrintWebViewHelperDelegateQt::GetPdfElement(blink::WebLocalFrame* frame)
+{
+    return blink::WebElement();
+}
+
+bool PrintWebViewHelperDelegateQt::IsPrintPreviewEnabled()
+{
+    return false;
+}
+
+bool PrintWebViewHelperDelegateQt::OverridePrint(blink::WebLocalFrame* frame)
+{
+    return false;
+}
+
+}
diff --git a/src/core/renderer/print_web_view_helper_delegate_qt.h b/src/core/renderer/print_web_view_helper_delegate_qt.h
new file mode 100644
index 000000000..a854242ba
--- /dev/null
+++ b/src/core/renderer/print_web_view_helper_delegate_qt.h
@@ -0,0 +1,65 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtWebEngine module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef PRINT_WEB_VIEW_HELPER_DELEGATE_QT_H
+#define PRINT_WEB_VIEW_HELPER_DELEGATE_QT_H
+
+#include "components/printing/renderer/print_web_view_helper.h"
+
+namespace QtWebEngineCore {
+
+class PrintWebViewHelperDelegateQt : public printing::PrintWebViewHelper::Delegate
+{
+public:
+    ~PrintWebViewHelperDelegateQt() override;
+
+    bool CancelPrerender(content::RenderView* render_view,
+                         int routing_id) override;
+
+    blink::WebElement GetPdfElement(blink::WebLocalFrame* frame) override;
+
+    bool IsPrintPreviewEnabled() override;
+
+    bool OverridePrint(blink::WebLocalFrame* frame) override;
+};  // class PrintWebViewHelperDelegateQt
+}
+
+#endif // PRINT_WEB_VIEW_HELPER_DELEGATE_QT_H
+
diff --git a/src/core/web_engine_context.cpp b/src/core/web_engine_context.cpp
index c28d60f95..f4574f8b3 100644
--- a/src/core/web_engine_context.cpp
+++ b/src/core/web_engine_context.cpp
@@ -48,6 +48,9 @@
 #include "base/run_loop.h"
 #include "base/threading/thread_restrictions.h"
 #include "cc/base/switches.h"
+#if defined(ENABLE_BASIC_PRINTING)
+#include "chrome/browser/printing/print_job_manager.h"
+#endif // defined(ENABLE_BASIC_PRINTING)
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/utility_process_host_impl.h"
@@ -287,6 +290,16 @@ WebEngineContext::WebEngineContext()
     // thread to avoid a thread check assertion in its constructor when it
     // first gets referenced on the IO thread.
     MediaCaptureDevicesDispatcher::GetInstance();
+
+#if defined(ENABLE_BASIC_PRINTING)
+    m_printJobManager.reset(new printing::PrintJobManager());
+#endif // defined(ENABLE_BASIC_PRINTING)
 }
 
+#if defined(ENABLE_BASIC_PRINTING)
+printing::PrintJobManager* WebEngineContext::getPrintJobManager()
+{
+    return m_printJobManager.get();
+}
+#endif // defined(ENABLE_BASIC_PRINTING)
 } // namespace
diff --git a/src/core/web_engine_context.h b/src/core/web_engine_context.h
index 6d40d72a2..3c69d87ca 100644
--- a/src/core/web_engine_context.h
+++ b/src/core/web_engine_context.h
@@ -58,6 +58,12 @@ class BrowserMainRunner;
 class ContentMainRunner;
 }
 
+#if defined(ENABLE_BASIC_PRINTING)
+namespace printing {
+class PrintJobManager;
+}
+#endif // defined(ENABLE_BASIC_PRINTING)
+
 QT_FORWARD_DECLARE_CLASS(QObject)
 
 namespace QtWebEngineCore {
@@ -72,7 +78,9 @@ public:
 
     QtWebEngineCore::BrowserContextAdapter *defaultBrowserContext();
     QObject *globalQObject();
-
+#if defined(ENABLE_BASIC_PRINTING)
+    printing::PrintJobManager* getPrintJobManager();
+#endif // defined(ENABLE_BASIC_PRINTING)
     void destroyBrowserContext();
     void destroy();
 
@@ -88,6 +96,9 @@ private:
     QObject* m_globalQObject;
     QExplicitlySharedDataPointer<BrowserContextAdapter> m_defaultBrowserContext;
     scoped_ptr<devtools_http_handler::DevToolsHttpHandler> m_devtools;
+#if defined(ENABLE_BASIC_PRINTING)
+    scoped_ptr<printing::PrintJobManager> m_printJobManager;
+#endif // defined(ENABLE_BASIC_PRINTING)
 };
 
 } // namespace