Merge branch 'devel'

Author: spajak

CHANGELOG.md

@@ -1,4 +1,13 @@
 Changelog
+===
+### 0.2.1 (2016-12-20)
+* Allow only specified schemes when in server mode (ie. block file:// access)
+* Added option to enable JavaScript --javascript
+* Added --file option to load file from command line
+* Disabled standard input (use --file instead)
+* Added --background option to print html backgrounds
+* Bulding with CEF 3.2883.1540.gedbfb20 / Chromium 55.0.2883.59 version (Windows & Linux, 64bit)
+
 ===
 ### 0.2.0 (2016-11-29)
 * Added HTTP server mode (use with --server flag)

src/Client.cpp

@@ -3,52 +3,76 @@
 #include "SchemeHandlerFactory.h"
 #include "PrintHandler.h"
 #include "RenderHandler.h"
+#include "RequestHandler.h"
 
+#include "include/base/cef_logging.h"
 #include "include/wrapper/cef_helpers.h"
 #include "include/base/cef_bind.h"
 #include "include/wrapper/cef_closure_task.h"
 
 namespace cefpdf {
 
-Client::Client(bool stopAfterLastJob) :
-    m_storage(new Storage),
+Client::Client() :
     m_jobsManager(new job::Manager()),
     m_processCount(0),
     m_initialized(false),
-    m_stopAfterLastJob(stopAfterLastJob),
+    m_running(false),
+    m_stopAfterLastJob(false),
     m_printHandler(new PrintHandler),
-    m_renderHandler(new RenderHandler)
+    m_renderHandler(new RenderHandler),
+    m_requestHandler(new RequestHandler)
 {
     m_settings.no_sandbox = true;
     m_settings.windowless_rendering_enabled = true;
     m_settings.command_line_args_disabled = true;
-    m_settings.uncaught_exception_stack_size = 20;
 
     m_windowInfo.windowless_rendering_enabled = true;
     m_windowInfo.transparent_painting_enabled = false;
 
     m_browserSettings.windowless_frame_rate = 1;
     CefString(&m_browserSettings.default_encoding).FromString(constants::encoding);
+    m_browserSettings.caret_browsing = STATE_DISABLED;
+    m_browserSettings.plugins = STATE_DISABLED;
     m_browserSettings.javascript_open_windows = STATE_DISABLED;
     m_browserSettings.javascript_close_windows = STATE_DISABLED;
-    m_browserSettings.plugins = STATE_DISABLED;
 }
 
-void Client::Run()
+int Client::ExecuteSubProcess(const CefMainArgs& mainArgs)
+{
+    return CefExecuteProcess(mainArgs, this, NULL);
+}
+
+void Client::Initialize(const CefMainArgs& mainArgs)
 {
     DCHECK(!m_initialized);
-    CefMainArgs mainArgs;
     CefInitialize(mainArgs, m_settings, this, NULL);
-    CefRunMessageLoop();
+    m_initialized = true;
+}
+
+void Client::Shutdown()
+{
+    DCHECK(m_initialized);
     CefShutdown();
     m_initialized = false;
 }
 
-void Client::Stop()
+void Client::Run()
 {
     DCHECK(m_initialized);
-    CefQuitMessageLoop();
-    m_initialized = false;
+    DCHECK(!m_running);
+    m_running = true;
+    CefRunMessageLoop();
+    m_running = false;
+    Shutdown();
+}
+
+void Client::Stop()
+{
+    if (m_running) {
+        CefQuitMessageLoop();
+    } else if (m_initialized) {
+        Shutdown();
+    }
 }
 
 void Client::PostJob(CefRefPtr<job::Job> job)
@@ -65,10 +89,6 @@ void Client::ProcessJobsQueue()
 
     while (!m_jobsQueue.empty() && m_processCount < constants::maxProcesses) {
         auto job = m_jobsQueue.front();
-        if (job->GetOutputPath().empty()) {
-            job->SetOutputPath(m_storage->Reserve());
-        }
-
         m_jobsManager->Queue(job);
         m_jobsQueue.pop();
         ++m_processCount;
@@ -90,6 +110,12 @@ void Client::OnRegisterCustomSchemes(CefRefPtr<CefSchemeRegistrar> registrar)
     registrar->AddCustomScheme(constants::scheme, true, false, false);
 }
 
+void Client::OnBeforeCommandLineProcessing(const CefString& process_type, CefRefPtr<CefCommandLine> command_line)
+{
+    command_line->AppendSwitch("disable-gpu");
+    command_line->AppendSwitch("disable-gpu-compositing");
+};
+
 // CefBrowserProcessHandler methods:
 // -----------------------------------------------------------------------------
 CefRefPtr<CefPrintHandler> Client::GetPrintHandler()
@@ -130,6 +156,11 @@ CefRefPtr<CefRenderHandler> Client::GetRenderHandler()
     return m_renderHandler;
 }
 
+CefRefPtr<CefRequestHandler> Client::GetRequestHandler()
+{
+    return m_requestHandler;
+}
+
 // CefLifeSpanHandler methods:
 // -----------------------------------------------------------------------------
 void Client::OnAfterCreated(CefRefPtr<CefBrowser> browser)
@@ -205,13 +236,8 @@ void Client::OnLoadError(
 
     CEF_REQUIRE_UI_THREAD();
 
-    // Don't display an error for downloaded files.
-    if (errorCode == ERR_ABORTED) {
-        return;
-    }
-
     if (frame->IsMain()) {
-        m_jobsManager->SetError(browser, errorCode);
+        m_jobsManager->Abort(browser, errorCode);
     }
 }
 

src/Client.h

@@ -2,13 +2,14 @@
 #define CLIENT_H_
 
 #include "Job/Manager.h"
-#include "Storage.h"
+#include "RequestHandler.h"
 
 #include "include/cef_app.h"
 #include "include/cef_client.h"
 #include "include/cef_browser.h"
 
 #include <queue>
+#include <set>
 
 namespace cefpdf {
 
@@ -20,32 +21,55 @@ class Client : public CefApp,
 {
 
 public:
-    Client(bool stopAfterLastJob = false);
+    Client();
     Client(const Client&) = delete;
     Client& operator=(const Client&) = delete;
 
+    // Execute subprocess, if any
+    int ExecuteSubProcess(const CefMainArgs&);
+
+    // Initialize CEF
+    void Initialize(const CefMainArgs&);
+
+    // De-initialize CEF
+    void Shutdown();
+
     // Run message loop
-    virtual void Run();
+    void Run();
 
-    // Stop message loop
+    // Stop message loop and/or shutdown CEF
     void Stop();
 
     // Add new job to the queue and process it
     void PostJob(CefRefPtr<job::Job> job);
 
-    // Get Storage object
-    CefRefPtr<Storage> GetStorage() {
-        return m_storage;
-    };
-
     // Get the number of running job processes
     unsigned int GetProcessCount() {
         return m_processCount;
     };
 
+    void SetStopAfterLastJob(bool flag) {
+        m_stopAfterLastJob = flag;
+    };
+
+    void SetDisableJavaScript(bool flag) {
+        m_browserSettings.javascript = flag ? STATE_DISABLED : STATE_ENABLED;
+    };
+
+    void SetAllowedSchemes(const std::set<std::string>& schemes) {
+        for (auto s: schemes) {
+            m_requestHandler->AddAllowedScheme(s);
+        }
+    };
+
+    void ClearAllowedSchemes() {
+        m_requestHandler->ClearAllowedSchemes();
+    };
+
     // CefApp methods:
     virtual CefRefPtr<CefBrowserProcessHandler> GetBrowserProcessHandler() override;
     virtual void OnRegisterCustomSchemes(CefRefPtr<CefSchemeRegistrar> registrar) override;
+    virtual void OnBeforeCommandLineProcessing(const CefString& process_type, CefRefPtr<CefCommandLine> command_line) override;
 
     // CefBrowserProcessHandler methods:
     virtual CefRefPtr<CefPrintHandler> GetPrintHandler() override;
@@ -56,6 +80,7 @@ class Client : public CefApp,
     virtual CefRefPtr<CefLifeSpanHandler> GetLifeSpanHandler() override;
     virtual CefRefPtr<CefLoadHandler> GetLoadHandler() override;
     virtual CefRefPtr<CefRenderHandler> GetRenderHandler() override;
+    virtual CefRefPtr<CefRequestHandler> GetRequestHandler() override;
 
     // CefLifeSpanHandler methods:
     virtual void OnAfterCreated(CefRefPtr<CefBrowser> browser) override;
@@ -84,18 +109,19 @@ class Client : public CefApp,
 private:
     void ProcessJobsQueue();
     std::queue<CefRefPtr<job::Job>> m_jobsQueue;
-    CefRefPtr<Storage> m_storage;
 
     CefSettings m_settings;
     CefWindowInfo m_windowInfo;
     CefBrowserSettings m_browserSettings;
     CefRefPtr<job::Manager> m_jobsManager;
     unsigned int m_processCount;
     bool m_initialized;
+    bool m_running;
     bool m_stopAfterLastJob;
 
     CefRefPtr<CefPrintHandler> m_printHandler;
     CefRefPtr<CefRenderHandler> m_renderHandler;
+    CefRefPtr<RequestHandler> m_requestHandler;
 
     // Include the default reference counting implementation.
     IMPLEMENT_REFCOUNTING(Client);