Added some missing explicit overrides. Removed redundant semicolons

Author: spajak

src/Client.h

@@ -46,25 +46,25 @@ class Client : public CefApp,
     // 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;
@@ -124,7 +124,7 @@ class Client : public CefApp,
     CefRefPtr<RequestHandler> m_requestHandler;
 
     // Include the default reference counting implementation.
-    IMPLEMENT_REFCOUNTING(Client);
+    IMPLEMENT_REFCOUNTING(Client)
 };
 
 } // namespace cefpdf

src/Job/ContentProvider.h

@@ -14,32 +14,32 @@ class ContentProvider : public Visitor
 {
 
 public:
-    ContentProvider() {};
+    ContentProvider() {}
 
     CefRefPtr<CefStreamReader> GetStreamReader() const {
         return m_reader;
-    };
+    }
 
-    virtual void visit(CefRefPtr<Local> job) {
+    virtual void visit(CefRefPtr<Local> job) override {
         m_reader = CefStreamReader::CreateForData(
             static_cast<void*>(const_cast<char*>(job->GetContent().c_str())),
             job->GetContent().size()
         );
-    };
+    }
 
-    virtual void visit(CefRefPtr<Remote> job) {
+    virtual void visit(CefRefPtr<Remote> job) override {
         // no implementation
-    };
+    }
 
-    virtual void visit(CefRefPtr<StdInput> job) {
+    virtual void visit(CefRefPtr<StdInput> job) override {
         m_reader = CefStreamReader::CreateForHandler(new StdInputStreamReader);
-    };
+    }
 
 private:
     CefRefPtr<CefStreamReader> m_reader;
 
     // Include the default reference counting implementation.
-    IMPLEMENT_REFCOUNTING(ContentProvider);
+    IMPLEMENT_REFCOUNTING(ContentProvider)
 };
 
 } // namespace job

src/Job/Job.h

@@ -14,26 +14,27 @@ namespace job {
 
 class Job : public CefBaseRefCounted
 {
+
 public:
     Job();
 
     std::future<std::string> GetFuture() {
         return m_promise.get_future();
-    };
+    }
 
     void Resolve(std::string value) {
         m_promise.set_value(value);
-    };
+    }
 
     virtual void accept(CefRefPtr<Visitor> visitor) = 0;
 
     const CefString& GetOutputPath() const {
         return m_outputPath;
-    };
+    }
 
     void SetOutputPath(const CefString& outputPath) {
         m_outputPath = outputPath;
-    };
+    }
 
     void SetPageSize(const CefString& pageSize);
 
@@ -55,7 +56,7 @@ class Job : public CefBaseRefCounted
     std::promise<std::string> m_promise;
 
     // Include the default reference counting implementation.
-    IMPLEMENT_REFCOUNTING(Job);
+    IMPLEMENT_REFCOUNTING(Job)
 };
 
 } // namespace job

src/Job/Loader.h

@@ -17,25 +17,25 @@ class Loader : public Visitor
 
 public:
     Loader(CefRefPtr<CefFrame> frame) :
-        m_frame(frame) {};
+        m_frame(frame) {}
 
-    virtual void visit(CefRefPtr<Local> job) {
+    virtual void visit(CefRefPtr<Local> job) override {
         m_frame->LoadURL(cefpdf::constants::scheme + "://local");
-    };
+    }
 
-    virtual void visit(CefRefPtr<Remote> job) {
+    virtual void visit(CefRefPtr<Remote> job) override {
         m_frame->LoadURL(job->GetUrl());
-    };
+    }
 
-    virtual void visit(CefRefPtr<StdInput> job) {
+    virtual void visit(CefRefPtr<StdInput> job) override {
         m_frame->LoadURL(cefpdf::constants::scheme + "://stdin");
-    };
+    }
 
 private:
     CefRefPtr<CefFrame> m_frame;
 
     // Include the default reference counting implementation.
-    IMPLEMENT_REFCOUNTING(Loader);
+    IMPLEMENT_REFCOUNTING(Loader)
 };
 
 } // namespace job

src/Job/Local.h

@@ -10,25 +10,25 @@ class Local : public Job
 {
 
 public:
-    Local(const std::string& content) : Job(), m_content(content) {};
+    Local(const std::string& content) : Job(), m_content(content) {}
 
     virtual const std::string& GetContent() const {
         return m_content;
-    };
+    }
 
     void SetContent(const std::string& content) {
         m_content = content;
-    };
+    }
 
-    virtual void accept(CefRefPtr<Visitor> visitor) {
+    virtual void accept(CefRefPtr<Visitor> visitor) override {
         visitor->visit(this);
-    };
+    }
 
 private:
     std::string m_content;
 
     // Include the default reference counting implementation.
-    IMPLEMENT_REFCOUNTING(Local);
+    IMPLEMENT_REFCOUNTING(Local)
 };
 
 } // namespace job

src/Job/Manager.h

@@ -18,7 +18,7 @@ class Manager : public CefBaseRefCounted
 public:
     typedef CefLoadHandler::ErrorCode ErrorCode;
 
-    Manager() {};
+    Manager() {}
 
     std::size_t Queue(CefRefPtr<Job> job);
 
@@ -52,7 +52,7 @@ class Manager : public CefBaseRefCounted
     unsigned int m_counter = 0;
 
     // Include the default reference counting implementation.
-    IMPLEMENT_REFCOUNTING(Manager);
+    IMPLEMENT_REFCOUNTING(Manager)
 };
 
 } // namespace job

src/Job/Printer.h

@@ -17,39 +17,39 @@ class Printer : public Visitor,
 public:
     Printer(CefRefPtr<Manager> manager, CefRefPtr<CefBrowser> browser) :
         m_manager(manager),
-        m_browser(browser) {};
+        m_browser(browser) {}
 
     void Print(CefRefPtr<Job> job) {
         m_browser->GetHost()->PrintToPDF(
             job->GetOutputPath(),
             job->GetCefPdfPrintSettings(),
             this
         );
-    };
+    }
 
-    virtual void visit(CefRefPtr<Local> job) {
+    virtual void visit(CefRefPtr<Local> job) override {
         Print(job.get());
-    };
+    }
 
-    virtual void visit(CefRefPtr<Remote> job) {
+    virtual void visit(CefRefPtr<Remote> job) override {
         Print(job.get());
-    };
+    }
 
-    virtual void visit(CefRefPtr<StdInput> job) {
+    virtual void visit(CefRefPtr<StdInput> job) override {
         Print(job.get());
     }
 
     // CefPdfPrintCallback methods:
     void OnPdfPrintFinished(const CefString& path, bool ok) override {
         m_manager->Finish(m_browser, path, ok);
-    };
+    }
 
 private:
     CefRefPtr<Manager> m_manager;
     CefRefPtr<CefBrowser> m_browser;
 
     // Include the default reference counting implementation.
-    IMPLEMENT_REFCOUNTING(Printer);
+    IMPLEMENT_REFCOUNTING(Printer)
 };
 
 } // namespace job

src/Job/Remote.h

@@ -11,21 +11,21 @@ class Remote : public Job
 
 public:
     Remote(const CefString& url) :
-        Job(), m_url(url) {};
+        Job(), m_url(url) {}
 
     const CefString& GetUrl() const {
         return m_url;
-    };
+    }
 
-    virtual void accept(CefRefPtr<Visitor> visitor) {
+    virtual void accept(CefRefPtr<Visitor> visitor) override {
         visitor->visit(this);
-    };
+    }
 
 private:
     CefString m_url;
 
     // Include the default reference counting implementation.
-    IMPLEMENT_REFCOUNTING(Remote);
+    IMPLEMENT_REFCOUNTING(Remote)
 };
 
 } // namespace job

src/Job/StdInput.h

@@ -10,14 +10,13 @@ class StdInput : public Job
 {
 
 public:
-    virtual void accept(CefRefPtr<Visitor> visitor) {
+    virtual void accept(CefRefPtr<Visitor> visitor) override {
         visitor->visit(this);
-    };
+    }
 
 private:
-
     // Include the default reference counting implementation.
-    IMPLEMENT_REFCOUNTING(StdInput);
+    IMPLEMENT_REFCOUNTING(StdInput)
 };
 
 } // namespace job

src/Job/StdInputStreamReader.h

@@ -7,41 +7,39 @@
 #include <cstdio>
 #include <string>
 #include <iostream>
-#include <algorithm>
 
 namespace cefpdf {
 namespace job {
 
 class StdInputStreamReader : public CefReadHandler
 {
-    public:
 
-    StdInputStreamReader() : m_initialized(false) {};
+public:
+    StdInputStreamReader() : m_initialized(false) {}
 
     void Initialize();
 
-    virtual int Eof() {
+    virtual int Eof() override {
         return std::cin.eof() ? 1 : 0;
-    };
+    }
 
-    virtual bool MayBlock() {
+    virtual bool MayBlock() override {
         return true;
-    };
+    }
 
-    virtual std::size_t Read(void* ptr, std::size_t size, std::size_t n);
+    virtual std::size_t Read(void* ptr, std::size_t size, std::size_t n) override;
 
-    virtual int Seek(int64 offset, int whence);
+    virtual int Seek(int64 offset, int whence) override;
 
-    virtual int64 Tell() {
+    virtual int64 Tell() override {
         return std::cin.tellg();
-    };
-
-    private:
+    }
 
+private:
     bool m_initialized;
 
     // Include the default reference counting implementation.
-    IMPLEMENT_REFCOUNTING(StdInputStreamReader);
+    IMPLEMENT_REFCOUNTING(StdInputStreamReader)
 };
 
 } // namespace job

src/Job/Visitor.h

@@ -14,15 +14,15 @@ class Visitor : public CefBaseRefCounted
 {
 
 public:
-    Visitor() {};
+    Visitor() {}
 
     virtual void visit(CefRefPtr<Local>) = 0;
     virtual void visit(CefRefPtr<Remote>) = 0;
     virtual void visit(CefRefPtr<StdInput>) = 0;
 
 private:
     // Include the default reference counting implementation.
-    IMPLEMENT_REFCOUNTING(Visitor);
+    IMPLEMENT_REFCOUNTING(Visitor)
 };
 
 } // namespace job

src/PrintHandler.h

@@ -7,8 +7,8 @@ namespace cefpdf {
 
 class PrintHandler : public CefPrintHandler
 {
-    public:
 
+public:
     PrintHandler();
 
     // CefPrintHandler methods:
@@ -37,10 +37,9 @@ class PrintHandler : public CefPrintHandler
 
     virtual void OnPrintStart(CefRefPtr<CefBrowser> browser) override;
 
-    private:
-
+private:
     // Include the default reference counting implementation.
-    IMPLEMENT_REFCOUNTING(PrintHandler);
+    IMPLEMENT_REFCOUNTING(PrintHandler)
 };
 
 } // namespace cefpdf