upgrade cef version and add two feature

src/Client.cpp

@@ -6,8 +6,8 @@
 #include "RenderProcessHandler.h"
 
 #include "include/base/cef_logging.h"
+#include "include/base/cef_callback.h"
 #include "include/wrapper/cef_helpers.h"
-#include "include/base/cef_bind.h"
 #include "include/wrapper/cef_closure_task.h"
 
 #include <thread>
@@ -100,7 +100,7 @@ void Client::CreateBrowsers(unsigned int browserCount)
     while (m_pendingBrowsersCount > 0 && m_browsersCount <= constants::maxProcesses) {
         --m_pendingBrowsersCount;
         ++m_browsersCount;
-        CefBrowserHost::CreateBrowser(m_windowInfo, this, "", m_browserSettings, NULL, NULL);
+        CefBrowserHost::CreateBrowser(m_windowInfo, this, "", m_browserSettings, nullptr, nullptr);
     }
 }
 
@@ -230,7 +230,7 @@ void Client::OnBeforeClose(CefRefPtr<CefBrowser> browser)
     --m_browsersCount;
 
     if (0 == m_browsersCount && m_stopAfterLastJob) {
-        CefPostDelayedTask(TID_UI, base::Bind(&Client::Stop, this), 50);
+        CefPostDelayedTask(TID_UI, base::BindOnce(&Client::Stop, this), 50);
     } else {
         CreateBrowsers();
     }
@@ -265,7 +265,7 @@ void Client::OnLoadEnd(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame,
     if (frame->IsMain()) {
         if (httpStatusCode == 200 && m_delay > 0) {
             DLOG(INFO) << "Client::OnLoadEnd - waiting for " << m_delay << "ms before generating PDF";
-            CefPostDelayedTask(TID_UI, base::Bind(&Client::Process, this, browser), m_delay);
+            CefPostDelayedTask(TID_UI, base::BindOnce(&Client::Process, this, browser), m_delay);
         }
         else
             m_jobManager->Process(browser, httpStatusCode);

src/Common.cpp

@@ -11,13 +11,16 @@
 #include <random>
 #include <sstream>
 #include <iomanip>
+#include <filesystem>
 
 #if !defined(OS_WIN)
 #include <sys/types.h> // pid_t
 #include <sys/stat.h> // stat()
 #include <unistd.h> // access(), getcwd()
 #else
-#include "Shlwapi.h" // PathFileExistsW
+#include <direct.h>
+#include <shlobj.h>
+#include <Shlwapi.h> // PathFileExistsW
 #endif
 
 namespace cefpdf {
@@ -286,6 +289,23 @@ std::string pathToUri(const std::string& path)
     return std::string("file://") + uri;
 }
 
+std::string getDownloadDirectory() {
+  TCHAR szFolderPath[MAX_PATH];
+  std::string path;
+
+#if defined(OS_WIN)
+  // Save the file in the user's "My Documents" folder.
+  if (SUCCEEDED(SHGetFolderPath(nullptr, CSIDL_PERSONAL | CSIDL_FLAG_CREATE,
+                                nullptr, 0, szFolderPath))) {
+    path = CefString(szFolderPath);
+  }
+#else
+    path = getenv("HOME");
+#endif // OS_WIN
+
+  return path;
+}
+
 std::string getCurrentWorkingDirectory()
 {
 #if defined(OS_WIN)

src/Common.h

@@ -10,6 +10,8 @@
 
 namespace cefpdf {
 
+std::string getDownloadDirectory();
+
 std::string getCurrentWorkingDirectory();
 
 std::string getTempDirectory();
@@ -34,6 +36,8 @@ namespace constants {
 
     // Current working directory
     const std::string cwd = getCurrentWorkingDirectory();
+    // File save directory (including trailing slash)
+    const std::string save = getDownloadDirectory();
     // Temp directory (including trailing slash)
     const std::string tmp = getTempDirectory();
     // Current process ID

src/Job/Job.cpp

@@ -1,5 +1,9 @@
 #include "Job.h"
 
+#include <podofo.h>
+
+#include <filesystem>
+
 namespace cefpdf {
 namespace job {
 
@@ -43,6 +47,60 @@ void Job::SetScale(int scale)
     m_scale = scale;
 }
 
+void Job::SetCover(const std::string& path)
+{
+    m_cover = path;
+}
+
+void Job::SetAppendix(const std::string& path)
+{
+    m_appendix = path;
+}
+
+void Job::SetStatus(Status status) {
+    m_status = status;
+
+    if (Status::SUCCESS == status) {
+        std::error_code code;
+        std::string orgFile = m_outputPath.ToString() + ".org.pdf";
+        if (!m_cover.empty() || !m_appendix.empty()) {
+            std::filesystem::rename(m_outputPath.ToString(), orgFile, code);
+        }
+        if (0 == code.value()) {
+            try {
+                if (!m_cover.empty() && m_appendix.empty()) {
+                    PoDoFo::PdfMemDocument cover( m_cover.c_str() );
+                    PoDoFo::PdfMemDocument save( orgFile.c_str() );
+
+                    cover.Append( save );
+
+                    cover.Write( m_outputPath.c_str() );
+                } else if (!m_cover.empty() && !m_appendix.empty()) {
+                    PoDoFo::PdfMemDocument cover( m_cover.c_str() );
+                    PoDoFo::PdfMemDocument save( orgFile.c_str() );
+                    PoDoFo::PdfMemDocument appendix( m_appendix.c_str() );
+
+                    cover.Append( save );
+                    cover.Append( appendix );
+
+                    cover.Write( m_outputPath.c_str() );
+                } else if (m_cover.empty() && !m_appendix.empty()) {
+                    PoDoFo::PdfMemDocument save( orgFile.c_str() );
+                    PoDoFo::PdfMemDocument appendix( m_appendix.c_str() );
+
+                    save.Append( appendix );
+
+                    save.Write( m_outputPath.c_str() );
+                }
+
+                std::filesystem::remove(orgFile);
+            } catch( PoDoFo::PdfError & e ) {
+                throw e;
+            }
+        }
+    }
+}
+
 CefPdfPrintSettings Job::GetCefPdfPrintSettings() const
 {
     CefPdfPrintSettings pdfSettings;

src/Job/Job.h

@@ -61,16 +61,18 @@ class Job : public CefBaseRefCounted
 
     void SetScale(int scale);
 
+    void SetCover(const std::string& path);
+
+    void SetAppendix(const std::string& path);
+
     // Get prepared PDF setting for CEF
     CefPdfPrintSettings GetCefPdfPrintSettings() const;
 
     Status GetStatus() {
         return m_status;
     }
 
-    void SetStatus(Status status) {
-        m_status = status;
-    }
+    void SetStatus(Status status);
 
 private:
     CefString m_outputPath;
@@ -81,6 +83,8 @@ class Job : public CefBaseRefCounted
     Status m_status;
     Callback m_callback;
     int m_scale;
+    std::string m_cover;
+    std::string m_appendix;
 
     // Include the default reference counting implementation.
     IMPLEMENT_REFCOUNTING(Job);

src/Job/Manager.cpp

@@ -43,7 +43,7 @@ void Manager::Assign(CefRefPtr<CefBrowser> browser)
 
         m_jobsQueue.pop();
 
-        m_jobs.push_back(BrowserJob({browser, job, NULL}));
+        m_jobs.push_back(BrowserJob({browser, job, nullptr}));
 
         job->SetStatus(Job::Status::LOADING);
 
@@ -62,9 +62,9 @@ void Manager::Process(CefRefPtr<CefBrowser> browser, int httpStatusCode)
     if (it != m_jobs.end()) {
         if (!httpStatusCode || (200 <= httpStatusCode && 300 > httpStatusCode)) {
             // Generate file name if empty
-            if (it->job->GetOutputPath().empty()) {
-                it->job->SetOutputPath(reserveTempFile());
-            }
+            // if (it->job->GetOutputPath().empty()) {
+            //     it->job->SetOutputPath(reserveTempFile());
+            // }
 
             it->job->SetStatus(Job::Status::PRINTING);
 

src/PrintHandler.cpp

@@ -8,7 +8,8 @@ PrintHandler::PrintHandler() {}
 
 // CefPrintHandler methods:
 // -------------------------------------------------------------------------
-CefSize PrintHandler::GetPdfPaperSize(int device_units_per_inch)
+CefSize PrintHandler::GetPdfPaperSize(CefRefPtr<CefBrowser> browser,
+        int device_units_per_inch)
 {
     DLOG(INFO)
         << "PrintHandler::GetPdfPaperSize"

src/PrintHandler.h

@@ -12,7 +12,8 @@ class PrintHandler : public CefPrintHandler
     PrintHandler();
 
     // CefPrintHandler methods:
-    virtual CefSize GetPdfPaperSize(int device_units_per_inch) override;
+    virtual CefSize GetPdfPaperSize(CefRefPtr<CefBrowser> browser,
+        int device_units_per_inch) override;
 
     virtual bool OnPrintDialog(
         CefRefPtr<CefBrowser> browser,

src/SchemeHandlerFactory.cpp

@@ -20,7 +20,7 @@ CefRefPtr<CefResourceHandler> SchemeHandlerFactory::Create(
     auto streamReader = m_jobsManager->GetStreamReader(browser);
 
     if (!streamReader.get()) {
-        return NULL;
+        return nullptr;
     }
 
     return new CefStreamResourceHandler("text/html",  streamReader);

src/Server/Http.h

@@ -32,6 +32,7 @@ namespace headers {
     const std::string location    = "Content-Location";
     const std::string encoding    = "Transfer-Encoding";
     const std::string expect      = "Expect";
+    const std::string download    = "Download";
     const std::string pageSize    = "PDF-Page-Size";
     const std::string pageMargin  = "PDF-Page-Margin";
     const std::string pdfOptions  = "PDF-Options";
@@ -52,6 +53,7 @@ struct Request {
     std::size_t length;
     std::string encoding;
     bool chunked;
+    bool download;
     std::string expect;
     std::string location;
     std::string pageSize;

src/Server/Server.cpp

@@ -1,7 +1,7 @@
 #include "Server.h"
 
+#include "include/base/cef_callback.h"
 #include "include/wrapper/cef_helpers.h"
-#include "include/base/cef_bind.h"
 #include "include/wrapper/cef_closure_task.h"
 
 #include <iostream>
@@ -14,15 +14,18 @@ namespace server {
 Server::Server(
     CefRefPtr<cefpdf::Client> client,
     const std::string& address,
-    const std::string& port
+    const std::string& port,
+    const std::string& save,
+    const std::string& temp,
+    const bool& persistent
 ) :
     m_client(client),
     m_thread(),
     m_ioService(),
     m_signals(m_ioService),
     m_acceptor(m_ioService),
     m_socket(m_ioService),
-    m_sessionManager(new SessionManager),
+    m_sessionManager(new SessionManager(save, temp, persistent)),
     m_counter(0)
 {
     m_signals.add(SIGINT);
@@ -71,7 +74,7 @@ void Server::Run()
     Listen();
     m_ioService.run();
 
-    CefPostTask(TID_UI, base::Bind(&cefpdf::Client::Stop, m_client));
+    CefPostTask(TID_UI, base::BindOnce(&cefpdf::Client::Stop, m_client));
 
     DLOG(INFO) << "HTTP server thread finished";
 }

src/Server/Server.h

@@ -19,7 +19,7 @@ class Server : public CefBaseRefCounted
 {
 
 public:
-    Server(CefRefPtr<cefpdf::Client> client, std::string const&, std::string const&);
+    Server(CefRefPtr<cefpdf::Client> client, std::string const& host, std::string const& port, std::string const& save, std::string const& temp, bool const& persistent);
 
     void Start();