Format C++ files using clang-format

Author: Ortham

.clang-format

@@ -0,0 +1,15 @@
+---
+Language: Cpp
+BasedOnStyle: Google
+
+AccessModifierOffset: -2
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortIfStatementsOnASingleLine: false
+BinPackArguments: false
+BinPackParameters: false
+BreakConstructorInitializers: AfterColon
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+FixNamespaceComments: false
+SpaceAfterTemplateKeyword: false
+Standard: Cpp11
+...

CONTRIBUTING.md

@@ -76,7 +76,7 @@ LOOT's JavaScript uses a slightly tweaked version of the Airbnb style, and can b
 
 ### C++ Code Style
 
-The [Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html) is used as the base, with deviations as listed below.
+The [Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html) is used as the base, with deviations as listed below. Formatting style is codified in the repository's `.clang-format` file, but is not enforced.
 
 #### C++ Features
 
@@ -91,8 +91,3 @@ The [Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html)
 
 * Constant, enumerator and variable names should use `camelCase` or `underscore_separators`, but they should be consistent within the same scope.
 * Function names should use `PascalCase` or `camelCase`, but they should be consistent within the same scope.
-
-#### Formatting
-
-* Line length doesn't matter.
-* `public`, `protected` and `private` keywords should not be indented within a class declaration.

src/gui/cef/loot_app.cpp

@@ -24,15 +24,15 @@
 
 #include "gui/cef/loot_app.h"
 
-#include <boost/locale.hpp>
-#include <boost/log/trivial.hpp>
 #include <include/views/cef_browser_view.h>
 #include <include/views/cef_window.h>
+#include <boost/locale.hpp>
+#include <boost/log/trivial.hpp>
 
-#include "gui/state/loot_paths.h"
 #include "gui/cef/loot_handler.h"
 #include "gui/cef/loot_scheme_handler_factory.h"
 #include "gui/cef/window_delegate.h"
+#include "gui/state/loot_paths.h"
 
 namespace loot {
 void LootApp::Initialise(const std::string& defaultGame,
@@ -44,12 +44,13 @@ void LootApp::Initialise(const std::string& defaultGame,
   url_ = url;
 }
 
-void LootApp::OnBeforeCommandLineProcessing(const CefString& process_type,
-                                            CefRefPtr<CefCommandLine> command_line) {
+void LootApp::OnBeforeCommandLineProcessing(
+    const CefString& process_type,
+    CefRefPtr<CefCommandLine> command_line) {
   if (process_type.empty()) {
-      // Browser process, OK to modify the command line.
+    // Browser process, OK to modify the command line.
 
-      // Disable spell checking.
+    // Disable spell checking.
     command_line->AppendSwitch("--disable-spell-checking");
     command_line->AppendSwitch("--disable-extensions");
   }
@@ -64,14 +65,15 @@ CefRefPtr<CefRenderProcessHandler> LootApp::GetRenderProcessHandler() {
 }
 
 void LootApp::OnContextInitialized() {
-    //Make sure this is running in the UI thread.
+  // Make sure this is running in the UI thread.
   assert(CefCurrentlyOn(TID_UI));
 
   // Set the handler for browser-level callbacks.
   CefRefPtr<LootHandler> handler(new LootHandler(lootState_));
 
   // Register the custom "loot" domain handler.
-  CefRegisterSchemeHandlerFactory("http", "loot", new LootSchemeHandlerFactory());
+  CefRegisterSchemeHandlerFactory(
+      "http", "loot", new LootSchemeHandlerFactory());
 
   // Specify CEF browser settings here.
   CefBrowserSettings browser_settings;
@@ -84,35 +86,37 @@ void LootApp::OnContextInitialized() {
     gen.add_messages_path(LootPaths::getL10nPath().string());
     gen.add_messages_domain("loot");
 
-    BOOST_LOG_TRIVIAL(debug) << "Selected language: " << lootState_.getLanguage();
+    BOOST_LOG_TRIVIAL(debug)
+        << "Selected language: " << lootState_.getLanguage();
     std::locale::global(gen(lootState_.getLanguage() + ".UTF-8"));
     loot::InitialiseLocale(lootState_.getLanguage() + ".UTF-8");
     boost::filesystem::path::imbue(std::locale());
   }
 
-  CefRefPtr<CefBrowserView> browser_view = CefBrowserView::CreateBrowserView(handler, url_, browser_settings, NULL, NULL);
+  CefRefPtr<CefBrowserView> browser_view = CefBrowserView::CreateBrowserView(
+      handler, url_, browser_settings, NULL, NULL);
 
   CefWindow::CreateTopLevelWindow(new WindowDelegate(browser_view, lootState_));
 }
 
 void LootApp::OnWebKitInitialized() {
-    // Create the renderer-side router for query handling.
+  // Create the renderer-side router for query handling.
   CefMessageRouterConfig config;
   message_router_ = CefMessageRouterRendererSide::Create(config);
 }
 
-bool LootApp::OnProcessMessageReceived(
-  CefRefPtr<CefBrowser> browser,
-  CefProcessId source_process,
-  CefRefPtr<CefProcessMessage> message) {
+bool LootApp::OnProcessMessageReceived(CefRefPtr<CefBrowser> browser,
+                                       CefProcessId source_process,
+                                       CefRefPtr<CefProcessMessage> message) {
   // Handle IPC messages from the browser process...
-  return message_router_->OnProcessMessageReceived(browser, source_process, message);
+  return message_router_->OnProcessMessageReceived(
+      browser, source_process, message);
 }
 
 void LootApp::OnContextCreated(CefRefPtr<CefBrowser> browser,
                                CefRefPtr<CefFrame> frame,
                                CefRefPtr<CefV8Context> context) {
-    // Register javascript functions.
+  // Register javascript functions.
   message_router_->OnContextCreated(browser, frame, context);
 }
 }

src/gui/cef/loot_app.h

@@ -25,36 +25,39 @@
 #ifndef LOOT_GUI_LOOT_APP
 #define LOOT_GUI_LOOT_APP
 
-#include <include/cef_app.h>
 #include <include/base/cef_lock.h>
+#include <include/cef_app.h>
 #include <include/wrapper/cef_message_router.h>
 
 #include "gui/state/loot_state.h"
 
 namespace loot {
 class LootApp : public CefApp,
-  public CefBrowserProcessHandler,
-  public CefRenderProcessHandler {
+                public CefBrowserProcessHandler,
+                public CefRenderProcessHandler {
 public:
   void Initialise(const std::string& defaultGame,
                   const std::string& gameAppDataPath,
                   const std::string& lootDataPath,
                   const std::string& url);
 
   // Override CefApp methods.
-  virtual void OnBeforeCommandLineProcessing(const CefString& process_type,
-                                             CefRefPtr<CefCommandLine> command_line);
-  virtual CefRefPtr<CefBrowserProcessHandler> GetBrowserProcessHandler() OVERRIDE;
+  virtual void OnBeforeCommandLineProcessing(
+      const CefString& process_type,
+      CefRefPtr<CefCommandLine> command_line);
+  virtual CefRefPtr<CefBrowserProcessHandler> GetBrowserProcessHandler()
+      OVERRIDE;
   virtual CefRefPtr<CefRenderProcessHandler> GetRenderProcessHandler() OVERRIDE;
 
   // Override CefBrowserProcessHandler methods.
   virtual void OnContextInitialized() OVERRIDE;
   virtual void OnWebKitInitialized() OVERRIDE;
 
   // Override CefRenderProcessHandler methods.
-  virtual bool OnProcessMessageReceived(CefRefPtr<CefBrowser> browser,
-                                        CefProcessId source_process,
-                                        CefRefPtr<CefProcessMessage> message) OVERRIDE;
+  virtual bool OnProcessMessageReceived(
+      CefRefPtr<CefBrowser> browser,
+      CefProcessId source_process,
+      CefRefPtr<CefProcessMessage> message) OVERRIDE;
 
 private:
   virtual void OnContextCreated(CefRefPtr<CefBrowser> browser,

src/gui/cef/loot_handler.cpp

@@ -28,40 +28,36 @@
 #include <sstream>
 #include <string>
 
-#include <boost/algorithm/string.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/log/trivial.hpp>
 #include <include/cef_app.h>
 #include <include/views/cef_browser_view.h>
 #include <include/views/cef_window.h>
+#include <boost/algorithm/string.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/log/trivial.hpp>
 
-#include "gui/state/loot_paths.h"
-#include "gui/helpers.h"
 #include "gui/cef/loot_scheme_handler_factory.h"
 #include "gui/cef/query/query_handler.h"
+#include "gui/helpers.h"
+#include "gui/state/loot_paths.h"
 
 namespace loot {
 LootHandler::LootHandler(LootState& lootState) : lootState_(lootState) {}
 
 // CefClient methods
 //------------------
 
-CefRefPtr<CefDisplayHandler> LootHandler::GetDisplayHandler() {
-  return this;
-}
+CefRefPtr<CefDisplayHandler> LootHandler::GetDisplayHandler() { return this; }
 
-CefRefPtr<CefLifeSpanHandler> LootHandler::GetLifeSpanHandler() {
-  return this;
-}
+CefRefPtr<CefLifeSpanHandler> LootHandler::GetLifeSpanHandler() { return this; }
 
-CefRefPtr<CefLoadHandler> LootHandler::GetLoadHandler() {
-  return this;
-}
+CefRefPtr<CefLoadHandler> LootHandler::GetLoadHandler() { return this; }
 
-bool LootHandler::OnProcessMessageReceived(CefRefPtr<CefBrowser> browser,
-                                           CefProcessId source_process,
-                                           CefRefPtr<CefProcessMessage> message) {
-  return browser_side_router_->OnProcessMessageReceived(browser, source_process, message);
+bool LootHandler::OnProcessMessageReceived(
+    CefRefPtr<CefBrowser> browser,
+    CefProcessId source_process,
+    CefRefPtr<CefProcessMessage> message) {
+  return browser_side_router_->OnProcessMessageReceived(
+      browser, source_process, message);
 }
 
 // CefLifeSpanHandler methods
@@ -85,26 +81,30 @@ bool LootHandler::DoClose(CefRefPtr<CefBrowser> browser) {
 
   // Check if unapplied changes exist.
   if (lootState_.hasUnappliedChanges()) {
-    browser->GetMainFrame()->ExecuteJavaScript("onQuit();", browser->GetMainFrame()->GetURL(), 0);
+    browser->GetMainFrame()->ExecuteJavaScript(
+        "onQuit();", browser->GetMainFrame()->GetURL(), 0);
     return true;
   }
 
   auto browserView = CefBrowserView::GetForBrowser(browser);
   if (browserView == nullptr) {
-    BOOST_LOG_TRIVIAL(error) << "Failed to save LOOT's settings, browser view is null";
+    BOOST_LOG_TRIVIAL(error)
+        << "Failed to save LOOT's settings, browser view is null";
     return false;
   }
 
   auto window = browserView->GetWindow();
   if (window == nullptr) {
-    BOOST_LOG_TRIVIAL(error) << "Failed to save LOOT's settings, window is null";
+    BOOST_LOG_TRIVIAL(error)
+        << "Failed to save LOOT's settings, window is null";
     return false;
   }
 
   LootSettings::WindowPosition position;
   position.maximised = window->IsMaximized();
 
-  // Un-maximise the window so that the non-maximised size and position are recorded.
+  // Un-maximise the window so that the non-maximised size and position are
+  // recorded.
   window->Restore();
 
   CefRect windowBounds = window->GetBoundsInScreen();
@@ -116,9 +116,9 @@ bool LootHandler::DoClose(CefRefPtr<CefBrowser> browser) {
 
   try {
     lootState_.save(LootPaths::getSettingsPath());
-  }
-  catch (std::exception &e) {
-    BOOST_LOG_TRIVIAL(error) << "Failed to save LOOT's settings. Error: " << e.what();
+  } catch (std::exception& e) {
+    BOOST_LOG_TRIVIAL(error)
+        << "Failed to save LOOT's settings. Error: " << e.what();
   }
 
   // Allow the close. For windowed browsers this will result in the OS close
@@ -133,15 +133,17 @@ void LootHandler::OnBeforeClose(CefRefPtr<CefBrowser> browser) {
   browser_side_router_->OnBeforeClose(browser);
 
   // Remove from the list of existing browsers.
-  for (BrowserList::iterator bit = browser_list_.begin(); bit != browser_list_.end(); ++bit) {
+  for (BrowserList::iterator bit = browser_list_.begin();
+       bit != browser_list_.end();
+       ++bit) {
     if ((*bit)->IsSame(browser)) {
       browser_list_.erase(bit);
       break;
     }
   }
 
   if (browser_list_.empty()) {
-      // All browser windows have closed. Quit the application message loop.
+    // All browser windows have closed. Quit the application message loop.
     CefQuitMessageLoop();
   }
 }
@@ -160,50 +162,55 @@ void LootHandler::OnLoadError(CefRefPtr<CefBrowser> browser,
   if (errorCode == ERR_ABORTED)
     return;
 
-// Display a load error message.
+  // Display a load error message.
   std::stringstream ss;
   ss << "<html><body bgcolor=\"white\">"
-    << "<h2>Failed to load URL " << std::string(failedUrl)
-    << " with error " << std::string(errorText) << " (" << errorCode
-    << ").</h2></body></html>";
+     << "<h2>Failed to load URL " << std::string(failedUrl) << " with error "
+     << std::string(errorText) << " (" << errorCode << ").</h2></body></html>";
 
   frame->LoadString(ss.str(), failedUrl);
 }
 
 // CefRequestHandler methods
 //--------------------------
 
-CefRefPtr<CefRequestHandler> LootHandler::GetRequestHandler() {
-  return this;
-}
+CefRefPtr<CefRequestHandler> LootHandler::GetRequestHandler() { return this; }
 
-bool LootHandler::OnBeforeBrowse(CefRefPtr< CefBrowser > browser,
-                                 CefRefPtr< CefFrame > frame,
-                                 CefRefPtr< CefRequest > request,
+bool LootHandler::OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
+                                 CefRefPtr<CefFrame> frame,
+                                 CefRefPtr<CefRequest> request,
                                  bool is_redirect) {
-  BOOST_LOG_TRIVIAL(trace) << "Attempting to open link: " << request->GetURL().ToString();
+  BOOST_LOG_TRIVIAL(trace) << "Attempting to open link: "
+                           << request->GetURL().ToString();
 
   const std::string url = request->GetURL().ToString();
   if (boost::starts_with(url, "http://loot/")) {
-    BOOST_LOG_TRIVIAL(trace) << "Link is to LOOT page, allowing CEF's default handling.";
+    BOOST_LOG_TRIVIAL(trace)
+        << "Link is to LOOT page, allowing CEF's default handling.";
     return false;
   } else if (boost::starts_with(url, "http://localhost:")) {
-    BOOST_LOG_TRIVIAL(warning) << "Link is to a page on localhost, if this isn't happening while running tests, something has gone wrong";
+    BOOST_LOG_TRIVIAL(warning) << "Link is to a page on localhost, if this "
+                                  "isn't happening while running tests, "
+                                  "something has gone wrong";
     return false;
   }
 
   BOOST_LOG_TRIVIAL(info) << "Opening link in Windows' default handler.";
-  OpenInDefaultApplication(boost::filesystem::path(request->GetURL().ToString()));
+  OpenInDefaultApplication(
+      boost::filesystem::path(request->GetURL().ToString()));
 
   return true;
 }
 
-CefRequestHandler::ReturnValue LootHandler::OnBeforeResourceLoad(CefRefPtr<CefBrowser> browser,
-                                                                 CefRefPtr<CefFrame> frame,
-                                                                 CefRefPtr<CefRequest> request,
-                                                                 CefRefPtr<CefRequestCallback> callback) {
-  if (boost::starts_with(request->GetURL().ToString(), "https://fonts.googleapis.com")) {
-    BOOST_LOG_TRIVIAL(warning) << "Blocking load of resource at " << request->GetURL().ToString();
+CefRequestHandler::ReturnValue LootHandler::OnBeforeResourceLoad(
+    CefRefPtr<CefBrowser> browser,
+    CefRefPtr<CefFrame> frame,
+    CefRefPtr<CefRequest> request,
+    CefRefPtr<CefRequestCallback> callback) {
+  if (boost::starts_with(request->GetURL().ToString(),
+                         "https://fonts.googleapis.com")) {
+    BOOST_LOG_TRIVIAL(warning)
+        << "Blocking load of resource at " << request->GetURL().ToString();
     return RV_CANCEL;
   }