diff --git a/libcef/browser/alloy/alloy_browser_context.cc b/libcef/browser/alloy/alloy_browser_context.cc
index aa6a6610b..d5dfd1aa8 100644
--- a/libcef/browser/alloy/alloy_browser_context.cc
+++ b/libcef/browser/alloy/alloy_browser_context.cc
@@ -80,22 +80,25 @@ class CefVisitedLinkListener : public visitedlink::VisitedLinkWriter::Listener {
   void NewTable(base::ReadOnlySharedMemoryRegion* table_region) override {
     CEF_REQUIRE_UIT();
     ListenerMap::iterator it = listener_map_.begin();
-    for (; it != listener_map_.end(); ++it)
+    for (; it != listener_map_.end(); ++it) {
       it->second->NewTable(table_region);
+    }
   }
 
   void Add(visitedlink::VisitedLinkCommon::Fingerprint fingerprint) override {
     CEF_REQUIRE_UIT();
     ListenerMap::iterator it = listener_map_.begin();
-    for (; it != listener_map_.end(); ++it)
+    for (; it != listener_map_.end(); ++it) {
       it->second->Add(fingerprint);
+    }
   }
 
   void Reset(bool invalidate_hashes) override {
     CEF_REQUIRE_UIT();
     ListenerMap::iterator it = listener_map_.begin();
-    for (; it != listener_map_.end(); ++it)
+    for (; it != listener_map_.end(); ++it) {
       it->second->Reset(invalidate_hashes);
+    }
   }
 
  private:
@@ -161,8 +164,9 @@ void AlloyBrowserContext::Initialize() {
 
   // Initialize visited links management.
   base::FilePath visited_link_path;
-  if (!cache_path_.empty())
+  if (!cache_path_.empty()) {
     visited_link_path = cache_path_.Append(FILE_PATH_LITERAL("Visited Links"));
+  }
   visitedlink_listener_ = new CefVisitedLinkListener;
   visitedlink_master_.reset(new visitedlink::VisitedLinkWriter(
       visitedlink_listener_, this, !visited_link_path.empty(), false,
@@ -181,8 +185,9 @@ void AlloyBrowserContext::Initialize() {
   user_prefs::UserPrefs::Set(this, pref_service);
   key_->SetPrefs(pref_service);
 
-  if (extensions_enabled)
+  if (extensions_enabled) {
     extension_system_->Init();
+  }
 
   ChromePluginServiceFilter::GetInstance()->RegisterProfile(this);
 
@@ -227,8 +232,9 @@ void AlloyBrowserContext::Shutdown() {
 
   // Delete the download manager delegate here because otherwise we'll crash
   // when it's accessed from the content::BrowserContext destructor.
-  if (download_manager_delegate_)
+  if (download_manager_delegate_) {
     download_manager_delegate_.reset(nullptr);
+  }
 }
 
 void AlloyBrowserContext::RemoveCefRequestContext(
@@ -249,8 +255,9 @@ void AlloyBrowserContext::LoadExtension(
     CefRefPtr<CefExtensionHandler> handler,
     CefRefPtr<CefRequestContext> loader_context) {
   if (!extensions::ExtensionsEnabled()) {
-    if (handler)
+    if (handler) {
       handler->OnExtensionLoadFailed(ERR_ABORTED);
+    }
     return;
   }
 
@@ -267,23 +274,26 @@ void AlloyBrowserContext::LoadExtension(
 }
 
 bool AlloyBrowserContext::GetExtensions(std::vector<CefString>& extension_ids) {
-  if (!extensions::ExtensionsEnabled())
+  if (!extensions::ExtensionsEnabled()) {
     return false;
+  }
 
   extensions::CefExtensionSystem::ExtensionMap extension_map =
       extension_system()->GetExtensions();
   extensions::CefExtensionSystem::ExtensionMap::const_iterator it =
       extension_map.begin();
-  for (; it != extension_map.end(); ++it)
+  for (; it != extension_map.end(); ++it) {
     extension_ids.push_back(it->second->GetIdentifier());
+  }
 
   return true;
 }
 
 CefRefPtr<CefExtension> AlloyBrowserContext::GetExtension(
     const CefString& extension_id) {
-  if (!extensions::ExtensionsEnabled())
+  if (!extensions::ExtensionsEnabled()) {
     return nullptr;
+  }
 
   return extension_system()->GetExtension(extension_id);
 }
@@ -295,8 +305,9 @@ bool AlloyBrowserContext::UnloadExtension(const CefString& extension_id) {
 
 bool AlloyBrowserContext::IsPrintPreviewSupported() const {
   CEF_REQUIRE_UIT();
-  if (!extensions::PrintPreviewEnabled())
+  if (!extensions::PrintPreviewEnabled()) {
     return false;
+  }
 
   return !GetPrefs()->GetBoolean(prefs::kPrintPreviewDisabled);
 }
@@ -334,8 +345,9 @@ base::FilePath AlloyBrowserContext::GetPath() const {
 std::unique_ptr<content::ZoomLevelDelegate>
 AlloyBrowserContext::CreateZoomLevelDelegate(
     const base::FilePath& partition_path) {
-  if (cache_path_.empty())
+  if (cache_path_.empty()) {
     return std::unique_ptr<content::ZoomLevelDelegate>();
+  }
 
   return base::WrapUnique(new ChromeZoomLevelPrefs(
       GetPrefs(), cache_path_, partition_path,
@@ -352,8 +364,9 @@ AlloyBrowserContext::GetDownloadManagerDelegate() {
 }
 
 content::BrowserPluginGuestManager* AlloyBrowserContext::GetGuestManager() {
-  if (!extensions::ExtensionsEnabled())
+  if (!extensions::ExtensionsEnabled()) {
     return nullptr;
+  }
   return guest_view::GuestViewManager::FromBrowserContext(this);
 }
 
@@ -376,8 +389,9 @@ AlloyBrowserContext::GetStorageNotificationService() {
 }
 
 content::SSLHostStateDelegate* AlloyBrowserContext::GetSSLHostStateDelegate() {
-  if (!ssl_host_state_delegate_)
+  if (!ssl_host_state_delegate_) {
     ssl_host_state_delegate_.reset(new CefSSLHostStateDelegate());
+  }
   return ssl_host_state_delegate_.get();
 }
 
diff --git a/libcef/browser/alloy/alloy_browser_host_impl.cc b/libcef/browser/alloy/alloy_browser_host_impl.cc
index 2eaec5b07..c90b85cce 100644
--- a/libcef/browser/alloy/alloy_browser_host_impl.cc
+++ b/libcef/browser/alloy/alloy_browser_host_impl.cc
@@ -130,8 +130,9 @@ CefRefPtr<AlloyBrowserHostImpl> AlloyBrowserHostImpl::Create(
       static_cast<AlloyBrowserHostImpl*>(create_params.devtools_opener.get()),
       is_devtools_popup, request_context_impl, std::move(platform_delegate),
       cef_extension);
-  if (!browser)
+  if (!browser) {
     return nullptr;
+  }
 
   GURL url = url_util::MakeGURL(create_params.url, /*fixup=*/true);
 
@@ -173,8 +174,9 @@ CefRefPtr<AlloyBrowserHostImpl> AlloyBrowserHostImpl::CreateInternal(
   if (opener) {
     if (!opener->platform_delegate_) {
       // The opener window is being destroyed. Cancel the popup.
-      if (own_web_contents)
+      if (own_web_contents) {
         delete web_contents;
+      }
       return nullptr;
     }
 
@@ -193,8 +195,9 @@ CefRefPtr<AlloyBrowserHostImpl> AlloyBrowserHostImpl::CreateInternal(
       std::move(platform_delegate), extension);
   browser->InitializeBrowser();
 
-  if (!browser->CreateHostWindow())
+  if (!browser->CreateHostWindow()) {
     return nullptr;
+  }
 
   // Notify that the browser has been created. These must be delivered in the
   // expected order.
@@ -316,8 +319,9 @@ CefWindowHandle AlloyBrowserHostImpl::GetWindowHandle() {
   if (is_views_hosted_ && CEF_CURRENTLY_ON_UIT()) {
     // Always return the most up-to-date window handle for a views-hosted
     // browser since it may change if the view is re-parented.
-    if (platform_delegate_)
+    if (platform_delegate_) {
       return platform_delegate_->GetHostWindowHandle();
+    }
   }
   return host_window_handle_;
 }
@@ -333,16 +337,18 @@ double AlloyBrowserHostImpl::GetZoomLevel() {
     return 0;
   }
 
-  if (web_contents())
+  if (web_contents()) {
     return content::HostZoomMap::GetZoomLevel(web_contents());
+  }
 
   return 0;
 }
 
 void AlloyBrowserHostImpl::SetZoomLevel(double zoomLevel) {
   if (CEF_CURRENTLY_ON_UIT()) {
-    if (web_contents())
+    if (web_contents()) {
       content::HostZoomMap::SetZoomLevel(web_contents(), zoomLevel);
+    }
   } else {
     CEF_POST_TASK(CEF_UIT, base::BindOnce(&AlloyBrowserHostImpl::SetZoomLevel,
                                           this, zoomLevel));
@@ -372,8 +378,9 @@ void AlloyBrowserHostImpl::StopFinding(bool clearSelection) {
     return;
   }
 
-  if (platform_delegate_)
+  if (platform_delegate_) {
     platform_delegate_->StopFinding(clearSelection);
+  }
 }
 
 void AlloyBrowserHostImpl::ShowDevTools(const CefWindowInfo& windowInfo,
@@ -387,8 +394,9 @@ void AlloyBrowserHostImpl::ShowDevTools(const CefWindowInfo& windowInfo,
     return;
   }
 
-  if (!EnsureDevToolsManager())
+  if (!EnsureDevToolsManager()) {
     return;
+  }
   devtools_manager_->ShowDevTools(windowInfo, client, settings,
                                   inspect_element_at);
 }
@@ -400,8 +408,9 @@ void AlloyBrowserHostImpl::CloseDevTools() {
     return;
   }
 
-  if (!devtools_manager_)
+  if (!devtools_manager_) {
     return;
+  }
   devtools_manager_->CloseDevTools();
 }
 
@@ -411,8 +420,9 @@ bool AlloyBrowserHostImpl::HasDevTools() {
     return false;
   }
 
-  if (!devtools_manager_)
+  if (!devtools_manager_) {
     return false;
+  }
   return devtools_manager_->HasDevTools();
 }
 
@@ -464,8 +474,9 @@ void AlloyBrowserHostImpl::WasResized() {
     return;
   }
 
-  if (platform_delegate_)
+  if (platform_delegate_) {
     platform_delegate_->WasResized();
+  }
 }
 
 void AlloyBrowserHostImpl::WasHidden(bool hidden) {
@@ -480,8 +491,9 @@ void AlloyBrowserHostImpl::WasHidden(bool hidden) {
     return;
   }
 
-  if (platform_delegate_)
+  if (platform_delegate_) {
     platform_delegate_->WasHidden(hidden);
+  }
 }
 
 void AlloyBrowserHostImpl::NotifyScreenInfoChanged() {
@@ -497,8 +509,9 @@ void AlloyBrowserHostImpl::NotifyScreenInfoChanged() {
     return;
   }
 
-  if (platform_delegate_)
+  if (platform_delegate_) {
     platform_delegate_->NotifyScreenInfoChanged();
+  }
 }
 
 void AlloyBrowserHostImpl::Invalidate(PaintElementType type) {
@@ -513,8 +526,9 @@ void AlloyBrowserHostImpl::Invalidate(PaintElementType type) {
     return;
   }
 
-  if (platform_delegate_)
+  if (platform_delegate_) {
     platform_delegate_->Invalidate(type);
+  }
 }
 
 void AlloyBrowserHostImpl::SendExternalBeginFrame() {
@@ -530,8 +544,9 @@ void AlloyBrowserHostImpl::SendExternalBeginFrame() {
     return;
   }
 
-  if (platform_delegate_)
+  if (platform_delegate_) {
     platform_delegate_->SendExternalBeginFrame();
+  }
 }
 
 void AlloyBrowserHostImpl::SendTouchEvent(const CefTouchEvent& event) {
@@ -546,8 +561,9 @@ void AlloyBrowserHostImpl::SendTouchEvent(const CefTouchEvent& event) {
     return;
   }
 
-  if (platform_delegate_)
+  if (platform_delegate_) {
     platform_delegate_->SendTouchEvent(event);
+  }
 }
 
 void AlloyBrowserHostImpl::SendCaptureLostEvent() {
@@ -558,8 +574,9 @@ void AlloyBrowserHostImpl::SendCaptureLostEvent() {
     return;
   }
 
-  if (platform_delegate_)
+  if (platform_delegate_) {
     platform_delegate_->SendCaptureLostEvent();
+  }
 }
 
 int AlloyBrowserHostImpl::GetWindowlessFrameRate() {
@@ -582,8 +599,9 @@ void AlloyBrowserHostImpl::SetWindowlessFrameRate(int frame_rate) {
 
   settings_.windowless_frame_rate = frame_rate;
 
-  if (platform_delegate_)
+  if (platform_delegate_) {
     platform_delegate_->SetWindowlessFrameRate(frame_rate);
+  }
 }
 
 // AlloyBrowserHostImpl public methods.
@@ -635,10 +653,12 @@ void AlloyBrowserHostImpl::DestroyBrowser() {
   OnBeforeClose();
 
   // Destroy any platform constructs first.
-  if (javascript_dialog_manager_.get())
+  if (javascript_dialog_manager_.get()) {
     javascript_dialog_manager_->Destroy();
-  if (menu_manager_.get())
+  }
+  if (menu_manager_.get()) {
     menu_manager_->Destroy();
+  }
 
   // Notify any observers that may have state associated with this browser.
   OnBrowserDestroyed();
@@ -670,8 +690,9 @@ void AlloyBrowserHostImpl::DestroyBrowser() {
 
 void AlloyBrowserHostImpl::CancelContextMenu() {
   CEF_REQUIRE_UIT();
-  if (menu_manager_)
+  if (menu_manager_) {
     menu_manager_->CancelContextMenu();
+  }
 }
 
 bool AlloyBrowserHostImpl::MaybeAllowNavigation(
@@ -710,11 +731,13 @@ void AlloyBrowserHostImpl::OnSetFocus(cef_focus_source_t source) {
     return;
   }
 
-  if (contents_delegate_->OnSetFocus(source))
+  if (contents_delegate_->OnSetFocus(source)) {
     return;
+  }
 
-  if (platform_delegate_)
+  if (platform_delegate_) {
     platform_delegate_->SetFocus(true);
+  }
 }
 
 void AlloyBrowserHostImpl::EnterFullscreenModeForTab(
@@ -842,8 +865,9 @@ void AlloyBrowserHostImpl::ImeCancelComposition() {
     return;
   }
 
-  if (platform_delegate_)
+  if (platform_delegate_) {
     platform_delegate_->ImeCancelComposition();
+  }
 }
 
 void AlloyBrowserHostImpl::DragTargetDragEnter(
@@ -905,8 +929,9 @@ void AlloyBrowserHostImpl::DragTargetDragLeave() {
     return;
   }
 
-  if (platform_delegate_)
+  if (platform_delegate_) {
     platform_delegate_->DragTargetDragLeave();
+  }
 }
 
 void AlloyBrowserHostImpl::DragTargetDrop(const CefMouseEvent& event) {
@@ -921,8 +946,9 @@ void AlloyBrowserHostImpl::DragTargetDrop(const CefMouseEvent& event) {
     return;
   }
 
-  if (platform_delegate_)
+  if (platform_delegate_) {
     platform_delegate_->DragTargetDrop(event);
+  }
 }
 
 void AlloyBrowserHostImpl::DragSourceSystemDragEnded() {
@@ -938,8 +964,9 @@ void AlloyBrowserHostImpl::DragSourceSystemDragEnded() {
     return;
   }
 
-  if (platform_delegate_)
+  if (platform_delegate_) {
     platform_delegate_->DragSourceSystemDragEnded();
+  }
 }
 
 void AlloyBrowserHostImpl::DragSourceEndedAt(
@@ -958,8 +985,9 @@ void AlloyBrowserHostImpl::DragSourceEndedAt(
     return;
   }
 
-  if (platform_delegate_)
+  if (platform_delegate_) {
     platform_delegate_->DragSourceEndedAt(x, y, op);
+  }
 }
 
 void AlloyBrowserHostImpl::SetAudioMuted(bool mute) {
@@ -968,8 +996,9 @@ void AlloyBrowserHostImpl::SetAudioMuted(bool mute) {
                                           this, mute));
     return;
   }
-  if (!web_contents())
+  if (!web_contents()) {
     return;
+  }
   web_contents()->SetAudioMuted(mute);
 }
 
@@ -978,8 +1007,9 @@ bool AlloyBrowserHostImpl::IsAudioMuted() {
     NOTREACHED() << "called on invalid thread";
     return false;
   }
-  if (!web_contents())
+  if (!web_contents()) {
     return false;
+  }
   return web_contents()->IsAudioMuted();
 }
 
@@ -1028,8 +1058,9 @@ void AlloyBrowserHostImpl::LoadingStateChanged(content::WebContents* source,
 void AlloyBrowserHostImpl::CloseContents(content::WebContents* source) {
   CEF_REQUIRE_UIT();
 
-  if (destruction_state_ == DESTRUCTION_STATE_COMPLETED)
+  if (destruction_state_ == DESTRUCTION_STATE_COMPLETED) {
     return;
+  }
 
   bool close_browser = true;
 
@@ -1043,8 +1074,9 @@ void AlloyBrowserHostImpl::CloseContents(content::WebContents* source) {
   }
 
   if (close_browser) {
-    if (destruction_state_ != DESTRUCTION_STATE_ACCEPTED)
+    if (destruction_state_ != DESTRUCTION_STATE_ACCEPTED) {
       destruction_state_ = DESTRUCTION_STATE_ACCEPTED;
+    }
 
     if (!IsWindowless() && !window_destroyed_) {
       // A window exists so try to close it using the platform method. Will
@@ -1101,8 +1133,9 @@ bool AlloyBrowserHostImpl::TakeFocus(content::WebContents* source,
                                      bool reverse) {
   if (client_.get()) {
     CefRefPtr<CefFocusHandler> handler = client_->GetFocusHandler();
-    if (handler.get())
+    if (handler.get()) {
       handler->OnTakeFocus(this, !reverse);
+    }
   }
 
   return false;
@@ -1125,14 +1158,17 @@ bool AlloyBrowserHostImpl::HandleKeyboardEvent(
     content::WebContents* source,
     const content::NativeWebKeyboardEvent& event) {
   // Check to see if event should be ignored.
-  if (event.skip_in_browser)
+  if (event.skip_in_browser) {
     return false;
+  }
 
-  if (contents_delegate_->HandleKeyboardEvent(source, event))
+  if (contents_delegate_->HandleKeyboardEvent(source, event)) {
     return true;
+  }
 
-  if (platform_delegate_)
+  if (platform_delegate_) {
     return platform_delegate_->HandleKeyboardEvent(event);
+  }
   return false;
 }
 
@@ -1146,8 +1182,9 @@ bool AlloyBrowserHostImpl::CanDragEnter(content::WebContents* source,
                                         const content::DropData& data,
                                         blink::DragOperationsMask mask) {
   CefRefPtr<CefDragHandler> handler;
-  if (client_)
+  if (client_) {
     handler = client_->GetDragHandler();
+  }
   if (handler) {
     CefRefPtr<CefDragDataImpl> drag_data(new CefDragDataImpl(data));
     drag_data->SetReadOnly(true);
@@ -1200,8 +1237,9 @@ void AlloyBrowserHostImpl::WebContentsCreated(
 
   CefRefPtr<AlloyBrowserHostImpl> opener =
       GetBrowserForContents(source_contents);
-  if (!opener)
+  if (!opener) {
     return;
+  }
 
   // Popups must share the same RequestContext as the parent.
   CefRefPtr<CefRequestContextImpl> request_context = opener->request_context();
@@ -1251,8 +1289,9 @@ void AlloyBrowserHostImpl::UpdatePreferredSize(content::WebContents* source,
                                                const gfx::Size& pref_size) {
 #if BUILDFLAG(IS_WIN) || (BUILDFLAG(IS_POSIX) && !BUILDFLAG(IS_MAC))
   CEF_REQUIRE_UIT();
-  if (platform_delegate_)
+  if (platform_delegate_) {
     platform_delegate_->SizeTo(pref_size.width(), pref_size.height());
+  }
 #endif
 }
 
@@ -1336,13 +1375,15 @@ void AlloyBrowserHostImpl::DidFinishNavigation(
 
 void AlloyBrowserHostImpl::OnAudioStateChanged(bool audible) {
   if (audible) {
-    if (recently_audible_timer_)
+    if (recently_audible_timer_) {
       recently_audible_timer_->Stop();
+    }
 
     StartAudioCapturer();
   } else if (audio_capturer_) {
-    if (!recently_audible_timer_)
+    if (!recently_audible_timer_) {
       recently_audible_timer_ = std::make_unique<base::OneShotTimer>();
+    }
 
     // If you have a media playing that has a short quiet moment, web_contents
     // will immediately switch to non-audible state. We don't want to stop
@@ -1363,8 +1404,9 @@ void AlloyBrowserHostImpl::AccessibilityEventReceived(
     const content::AXEventNotificationDetails& content_event_bundle) {
   // Only needed in windowless mode.
   if (IsWindowless()) {
-    if (!web_contents() || !platform_delegate_)
+    if (!web_contents() || !platform_delegate_) {
       return;
+    }
 
     platform_delegate_->AccessibilityEventReceived(content_event_bundle);
   }
@@ -1374,8 +1416,9 @@ void AlloyBrowserHostImpl::AccessibilityLocationChangesReceived(
     const std::vector<content::AXLocationChangeNotificationDetails>& locData) {
   // Only needed in windowless mode.
   if (IsWindowless()) {
-    if (!web_contents() || !platform_delegate_)
+    if (!web_contents() || !platform_delegate_) {
       return;
+    }
 
     platform_delegate_->AccessibilityLocationChangesReceived(locData);
   }
@@ -1384,25 +1427,29 @@ void AlloyBrowserHostImpl::AccessibilityLocationChangesReceived(
 void AlloyBrowserHostImpl::WebContentsDestroyed() {
   auto wc = web_contents();
   content::WebContentsObserver::Observe(nullptr);
-  if (platform_delegate_)
+  if (platform_delegate_) {
     platform_delegate_->WebContentsDestroyed(wc);
+  }
 }
 
 void AlloyBrowserHostImpl::StartAudioCapturer() {
-  if (!client_.get() || audio_capturer_)
+  if (!client_.get() || audio_capturer_) {
     return;
+  }
 
   CefRefPtr<CefAudioHandler> audio_handler = client_->GetAudioHandler();
-  if (!audio_handler.get())
+  if (!audio_handler.get()) {
     return;
+  }
 
   CefAudioParameters params;
   params.channel_layout = CEF_CHANNEL_LAYOUT_STEREO;
   params.sample_rate = media::AudioParameters::kAudioCDSampleRate;
   params.frames_per_buffer = 1024;
 
-  if (!audio_handler->GetAudioParameters(this, params))
+  if (!audio_handler->GetAudioParameters(this, params)) {
     return;
+  }
 
   audio_capturer_.reset(new CefAudioCapturer(params, this, audio_handler));
 }
@@ -1447,18 +1494,21 @@ bool AlloyBrowserHostImpl::CreateHostWindow() {
   // |host_window_handle_| will not change after initial host creation for
   // non-views-hosted browsers.
   bool success = true;
-  if (!IsWindowless())
+  if (!IsWindowless()) {
     success = platform_delegate_->CreateHostWindow();
-  if (success && !is_views_hosted_)
+  }
+  if (success && !is_views_hosted_) {
     host_window_handle_ = platform_delegate_->GetHostWindowHandle();
+  }
   return success;
 }
 
 gfx::Point AlloyBrowserHostImpl::GetScreenPoint(const gfx::Point& view,
                                                 bool want_dip_coords) const {
   CEF_REQUIRE_UIT();
-  if (platform_delegate_)
+  if (platform_delegate_) {
     return platform_delegate_->GetScreenPoint(view, want_dip_coords);
+  }
   return gfx::Point();
 }
 
@@ -1477,6 +1527,7 @@ void AlloyBrowserHostImpl::StartDragging(
 
 void AlloyBrowserHostImpl::UpdateDragCursor(
     ui::mojom::DragOperation operation) {
-  if (platform_delegate_)
+  if (platform_delegate_) {
     platform_delegate_->UpdateDragCursor(operation);
+  }
 }
diff --git a/libcef/browser/alloy/alloy_browser_main.cc b/libcef/browser/alloy/alloy_browser_main.cc
index 56b6fbf1c..0d4a3c86c 100644
--- a/libcef/browser/alloy/alloy_browser_main.cc
+++ b/libcef/browser/alloy/alloy_browser_main.cc
@@ -122,13 +122,15 @@ class LinuxUiGetterImpl : public ui::LinuxUiGetter {
 ui::LinuxUi* GetLinuxUI() {
   // We can't use GtkUi in combination with multi-threaded-message-loop because
   // Chromium's GTK implementation doesn't use GDK threads.
-  if (!!CefContext::Get()->settings().multi_threaded_message_loop)
+  if (!!CefContext::Get()->settings().multi_threaded_message_loop) {
     return nullptr;
+  }
 
   // If the ozone backend hasn't provided a LinuxUiDelegate, don't try to create
   // a LinuxUi instance as this may result in a crash in toolkit initialization.
-  if (!ui::LinuxUiDelegate::GetInstance())
+  if (!ui::LinuxUiDelegate::GetInstance()) {
     return nullptr;
+  }
 
   return ui::GetDefaultLinuxUi();
 }
@@ -176,10 +178,11 @@ void AlloyBrowserMainParts::ToolkitInitialized() {
 #endif  // BUILDFLAG(IS_LINUX)
 
 #if BUILDFLAG(IS_MAC)
-  if (base::FeatureList::IsEnabled(features::kViewsJSAppModalDialog))
+  if (base::FeatureList::IsEnabled(features::kViewsJSAppModalDialog)) {
     InstallChromeJavaScriptAppModalDialogViewFactory();
-  else
+  } else {
     InstallChromeJavaScriptAppModalDialogViewCocoaFactory();
+  }
 #else
   InstallChromeJavaScriptAppModalDialogViewFactory();
 #endif
diff --git a/libcef/browser/alloy/alloy_content_browser_client.cc b/libcef/browser/alloy/alloy_content_browser_client.cc
index 7a65e3ea3..353d43fed 100644
--- a/libcef/browser/alloy/alloy_content_browser_client.cc
+++ b/libcef/browser/alloy/alloy_content_browser_client.cc
@@ -185,13 +185,15 @@ class CefSelectClientCertificateCallbackImpl
   ~CefSelectClientCertificateCallbackImpl() {
     // If Select has not been called, call it with NULL to continue without any
     // client certificate.
-    if (delegate_)
+    if (delegate_) {
       DoSelect(nullptr);
+    }
   }
 
   void Select(CefRefPtr<CefX509Certificate> cert) override {
-    if (delegate_)
+    if (delegate_) {
       DoSelect(cert);
+    }
   }
 
  private:
@@ -246,8 +248,9 @@ class CefSelectClientCertificateCallbackImpl
 
 #if BUILDFLAG(IS_POSIX) && !BUILDFLAG(IS_MAC)
 int GetCrashSignalFD() {
-  if (!crash_reporting::Enabled())
+  if (!crash_reporting::Enabled()) {
     return -1;
+  }
 
   int fd;
   pid_t pid;
@@ -262,8 +265,9 @@ void BindPluginInfoHost(
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   content::RenderProcessHost* host =
       content::RenderProcessHost::FromID(render_process_id);
-  if (!host)
+  if (!host) {
     return;
+  }
 
   Profile* profile = Profile::FromBrowserContext(host->GetBrowserContext());
   mojo::MakeSelfOwnedAssociatedReceiver(
@@ -300,12 +304,14 @@ base::FilePath GetRootCachePath() {
 const extensions::Extension* GetEnabledExtensionFromSiteURL(
     content::BrowserContext* context,
     const GURL& site_url) {
-  if (!site_url.SchemeIs(extensions::kExtensionScheme))
+  if (!site_url.SchemeIs(extensions::kExtensionScheme)) {
     return nullptr;
+  }
 
   auto registry = extensions::ExtensionRegistry::Get(context);
-  if (!registry)
+  if (!registry) {
     return nullptr;
+  }
 
   return registry->enabled_extensions().GetByID(site_url.host());
 }
@@ -394,11 +400,13 @@ bool AlloyContentBrowserClient::ShouldTreatURLSchemeAsFirstPartyWhenTopLevel(
   // with SameSite cookies on accounts.google.com, which are used for logging
   // into Cloud Print from chrome://print, for displaying a list of available
   // accounts on the NTP (chrome://new-tab-page), etc.
-  if (is_embedded_origin_secure && scheme == content::kChromeUIScheme)
+  if (is_embedded_origin_secure && scheme == content::kChromeUIScheme) {
     return true;
+  }
 
-  if (extensions::ExtensionsEnabled())
+  if (extensions::ExtensionsEnabled()) {
     return scheme == extensions::kExtensionScheme;
+  }
 
   return false;
 }
@@ -456,21 +464,24 @@ bool AlloyContentBrowserClient::IsWebUIAllowedToMakeNetworkRequests(
 }
 
 bool AlloyContentBrowserClient::IsHandledURL(const GURL& url) {
-  if (!url.is_valid())
+  if (!url.is_valid()) {
     return false;
+  }
   const std::string& scheme = url.scheme();
   DCHECK_EQ(scheme, base::ToLowerASCII(scheme));
 
-  if (scheme::IsInternalHandledScheme(scheme))
+  if (scheme::IsInternalHandledScheme(scheme)) {
     return true;
+  }
 
   return CefAppManager::Get()->HasCustomScheme(scheme);
 }
 
 void AlloyContentBrowserClient::SiteInstanceGotProcess(
     content::SiteInstance* site_instance) {
-  if (!extensions::ExtensionsEnabled())
+  if (!extensions::ExtensionsEnabled()) {
     return;
+  }
 
   CHECK(site_instance->HasProcess());
 
@@ -484,8 +495,9 @@ void AlloyContentBrowserClient::SiteInstanceGotProcess(
   // since it isn't treated as a hosted app.
   const auto extension =
       GetEnabledExtensionFromSiteURL(context, site_instance->GetSiteURL());
-  if (!extension)
+  if (!extension) {
     return;
+  }
 
   extensions::ProcessMap::Get(context)->Insert(
       extension->id(), site_instance->GetProcess()->GetID(),
@@ -494,21 +506,25 @@ void AlloyContentBrowserClient::SiteInstanceGotProcess(
 
 void AlloyContentBrowserClient::SiteInstanceDeleting(
     content::SiteInstance* site_instance) {
-  if (!extensions::ExtensionsEnabled())
+  if (!extensions::ExtensionsEnabled()) {
     return;
+  }
 
-  if (!site_instance->HasProcess())
+  if (!site_instance->HasProcess()) {
     return;
+  }
 
   auto context = site_instance->GetBrowserContext();
   auto registry = extensions::ExtensionRegistry::Get(context);
-  if (!registry)
+  if (!registry) {
     return;
+  }
 
   auto extension = registry->enabled_extensions().GetExtensionOrAppByURL(
       site_instance->GetSiteURL());
-  if (!extension)
+  if (!extension) {
     return;
+  }
 
   extensions::ProcessMap::Get(context)->Remove(
       extension->id(), site_instance->GetProcess()->GetID(),
@@ -619,8 +635,9 @@ void AlloyContentBrowserClient::AppendExtraCommandLineSwitches(
       // Force use of the sub-process executable path for the zygote process.
       const base::FilePath& subprocess_path =
           browser_cmd->GetSwitchValuePath(switches::kBrowserSubprocessPath);
-      if (!subprocess_path.empty())
+      if (!subprocess_path.empty()) {
         command_line->SetProgram(subprocess_path);
+      }
     }
 
     // Propagate the following switches to the zygote command line (along with
@@ -666,8 +683,9 @@ AlloyContentBrowserClient::GetSystemSharedURLLoaderFactory() {
       content::BrowserThread::CurrentlyOn(content::BrowserThread::UI) ||
       !content::BrowserThread::IsThreadInitialized(content::BrowserThread::UI));
 
-  if (!SystemNetworkContextManager::GetInstance())
+  if (!SystemNetworkContextManager::GetInstance()) {
     return nullptr;
+  }
 
   return SystemNetworkContextManager::GetInstance()
       ->GetSharedURLLoaderFactory();
@@ -688,8 +706,9 @@ content::SpeechRecognitionManagerDelegate*
 AlloyContentBrowserClient::CreateSpeechRecognitionManagerDelegate() {
   const base::CommandLine* command_line =
       base::CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(switches::kEnableSpeechInput))
+  if (command_line->HasSwitch(switches::kEnableSpeechInput)) {
     return new CefSpeechRecognitionManagerDelegate();
+  }
 
   return nullptr;
 }
@@ -732,8 +751,9 @@ base::OnceClosure AlloyContentBrowserClient::SelectClientCertificate(
       AlloyBrowserHostImpl::GetBrowserForContents(web_contents);
   if (browser.get()) {
     CefRefPtr<CefClient> client = browser->GetClient();
-    if (client.get())
+    if (client.get()) {
       handler = client->GetRequestHandler();
+    }
   }
 
   if (!handler.get()) {
@@ -865,13 +885,15 @@ AlloyContentBrowserClient::CreateThrottlesForNavigation(
   if (extensions::ExtensionsEnabled()) {
     auto pdf_iframe_throttle =
         PDFIFrameNavigationThrottle::MaybeCreateThrottleFor(navigation_handle);
-    if (pdf_iframe_throttle)
+    if (pdf_iframe_throttle) {
       throttles.push_back(std::move(pdf_iframe_throttle));
+    }
 
     auto pdf_throttle = pdf::PdfNavigationThrottle::MaybeCreateThrottleFor(
         navigation_handle, std::make_unique<ChromePdfStreamDelegate>());
-    if (pdf_throttle)
+    if (pdf_throttle) {
       throttles.push_back(std::move(pdf_throttle));
+    }
   }
 
   throttle::CreateThrottlesForNavigation(navigation_handle, throttles);
@@ -915,8 +937,9 @@ AlloyContentBrowserClient::WillCreateURLLoaderRequestInterceptors(
     auto pdf_interceptor =
         pdf::PdfURLLoaderRequestInterceptor::MaybeCreateInterceptor(
             frame_tree_node_id, std::make_unique<ChromePdfStreamDelegate>());
-    if (pdf_interceptor)
+    if (pdf_interceptor) {
       interceptors.push_back(std::move(pdf_interceptor));
+    }
   }
 
   return interceptors;
@@ -995,8 +1018,9 @@ void AlloyContentBrowserClient::RegisterNonNetworkNavigationURLLoaderFactories(
     int frame_tree_node_id,
     ukm::SourceIdObj ukm_source_id,
     NonNetworkURLLoaderFactoryMap* factories) {
-  if (!extensions::ExtensionsEnabled())
+  if (!extensions::ExtensionsEnabled()) {
     return;
+  }
 
   content::WebContents* web_contents =
       content::WebContents::FromFrameTreeNodeId(frame_tree_node_id);
@@ -1012,20 +1036,23 @@ void AlloyContentBrowserClient::RegisterNonNetworkSubresourceURLLoaderFactories(
     int render_frame_id,
     const absl::optional<url::Origin>& request_initiator_origin,
     NonNetworkURLLoaderFactoryMap* factories) {
-  if (!extensions::ExtensionsEnabled())
+  if (!extensions::ExtensionsEnabled()) {
     return;
+  }
 
   auto factory = extensions::CreateExtensionURLLoaderFactory(render_process_id,
                                                              render_frame_id);
-  if (factory)
+  if (factory) {
     factories->emplace(extensions::kExtensionScheme, std::move(factory));
+  }
 
   content::RenderFrameHost* frame_host =
       content::RenderFrameHost::FromID(render_process_id, render_frame_id);
   content::WebContents* web_contents =
       content::WebContents::FromRenderFrameHost(frame_host);
-  if (!web_contents)
+  if (!web_contents) {
     return;
+  }
 
   extensions::CefExtensionWebContentsObserver* web_observer =
       extensions::CefExtensionWebContentsObserver::FromWebContents(
@@ -1033,13 +1060,15 @@ void AlloyContentBrowserClient::RegisterNonNetworkSubresourceURLLoaderFactories(
 
   // There is nothing to do if no CefExtensionWebContentsObserver is attached
   // to the |web_contents|.
-  if (!web_observer)
+  if (!web_observer) {
     return;
+  }
 
   const extensions::Extension* extension =
       web_observer->GetExtensionFromFrame(frame_host, false);
-  if (!extension)
+  if (!extension) {
     return;
+  }
 
   std::vector<std::string> allowed_webui_hosts;
   // Support for chrome:// scheme if appropriate.
@@ -1222,25 +1251,29 @@ void AlloyContentBrowserClient::RegisterBrowserInterfaceBindersForFrame(
   map->Add<network_hints::mojom::NetworkHintsHandler>(
       base::BindRepeating(&BindNetworkHintsHandler));
 
-  if (!extensions::ExtensionsEnabled())
+  if (!extensions::ExtensionsEnabled()) {
     return;
+  }
 
   content::WebContents* web_contents =
       content::WebContents::FromRenderFrameHost(render_frame_host);
-  if (!web_contents)
+  if (!web_contents) {
     return;
+  }
 
   const GURL& site = render_frame_host->GetSiteInstance()->GetSiteURL();
-  if (!site.SchemeIs(extensions::kExtensionScheme))
+  if (!site.SchemeIs(extensions::kExtensionScheme)) {
     return;
+  }
 
   content::BrowserContext* browser_context =
       render_frame_host->GetProcess()->GetBrowserContext();
   auto* extension = extensions::ExtensionRegistry::Get(browser_context)
                         ->enabled_extensions()
                         .GetByID(site.host());
-  if (!extension)
+  if (!extension) {
     return;
+  }
   extensions::ExtensionsBrowserClient::Get()
       ->RegisterBrowserInterfaceBindersForFrame(map, render_frame_host,
                                                 extension);
@@ -1306,8 +1339,9 @@ AlloyContentBrowserClient::GetPluginMimeTypesWithExternalHandlers(
     content::BrowserContext* browser_context) {
   base::flat_set<std::string> mime_types;
   auto map = PluginUtils::GetMimeTypeToExtensionIdMap(browser_context);
-  for (const auto& pair : map)
+  for (const auto& pair : map) {
     mime_types.insert(pair.first);
+  }
   mime_types.insert(pdf::kInternalPluginMimeType);
   return mime_types;
 }
@@ -1372,8 +1406,9 @@ const extensions::Extension* AlloyContentBrowserClient::GetExtension(
     content::SiteInstance* site_instance) {
   extensions::ExtensionRegistry* registry =
       extensions::ExtensionRegistry::Get(site_instance->GetBrowserContext());
-  if (!registry)
+  if (!registry) {
     return nullptr;
+  }
   return registry->enabled_extensions().GetExtensionOrAppByURL(
       site_instance->GetSiteURL());
 }
diff --git a/libcef/browser/alloy/browser_platform_delegate_alloy.cc b/libcef/browser/alloy/browser_platform_delegate_alloy.cc
index 33ed00291..2620a5be9 100644
--- a/libcef/browser/alloy/browser_platform_delegate_alloy.cc
+++ b/libcef/browser/alloy/browser_platform_delegate_alloy.cc
@@ -161,8 +161,9 @@ void CefBrowserPlatformDelegateAlloy::BrowserCreated(
   CefBrowserPlatformDelegate::BrowserCreated(browser);
 
   // Only register WebContents delegate/observers if we're the primary delegate.
-  if (!primary_)
+  if (!primary_) {
     return;
+  }
 
   DCHECK(!web_contents_->GetDelegate());
   web_contents_->SetDelegate(static_cast<AlloyBrowserHostImpl*>(browser));
@@ -243,22 +244,26 @@ CefBrowserPlatformDelegateAlloy::GetWebContentsModalDialogHost() const {
 }
 
 void CefBrowserPlatformDelegateAlloy::SendCaptureLostEvent() {
-  if (!web_contents_)
+  if (!web_contents_) {
     return;
+  }
   content::RenderViewHost* host = web_contents_->GetRenderViewHost();
-  if (!host)
+  if (!host) {
     return;
+  }
 
   content::RenderWidgetHostImpl* widget =
       content::RenderWidgetHostImpl::From(host->GetWidget());
-  if (widget)
+  if (widget) {
     widget->LostCapture();
+  }
 }
 
 #if BUILDFLAG(IS_WIN) || (BUILDFLAG(IS_POSIX) && !BUILDFLAG(IS_MAC))
 void CefBrowserPlatformDelegateAlloy::NotifyMoveOrResizeStarted() {
-  if (!web_contents_)
+  if (!web_contents_) {
     return;
+  }
 
   // Dismiss any existing popups.
   web_contents_->ClearFocusedElement();
@@ -268,15 +273,17 @@ void CefBrowserPlatformDelegateAlloy::NotifyMoveOrResizeStarted() {
 bool CefBrowserPlatformDelegateAlloy::PreHandleGestureEvent(
     content::WebContents* source,
     const blink::WebGestureEvent& event) {
-  if (extension_host_)
+  if (extension_host_) {
     return extension_host_->PreHandleGestureEvent(source, event);
+  }
   return false;
 }
 
 bool CefBrowserPlatformDelegateAlloy::IsNeverComposited(
     content::WebContents* web_contents) {
-  if (extension_host_)
+  if (extension_host_) {
     return extension_host_->IsNeverComposited(web_contents);
+  }
   return false;
 }
 
@@ -284,8 +291,9 @@ void CefBrowserPlatformDelegateAlloy::SetAutoResizeEnabled(
     bool enabled,
     const CefSize& min_size,
     const CefSize& max_size) {
-  if (enabled == auto_resize_enabled_)
+  if (enabled == auto_resize_enabled_) {
     return;
+  }
 
   auto_resize_enabled_ = enabled;
   if (enabled) {
@@ -315,14 +323,16 @@ void CefBrowserPlatformDelegateAlloy::SetAccessibilityState(
   // Do nothing if state is set to default. It'll be disabled by default and
   // controlled by the commmand-line flags "force-renderer-accessibility" and
   // "disable-renderer-accessibility".
-  if (accessibility_state == STATE_DEFAULT)
+  if (accessibility_state == STATE_DEFAULT) {
     return;
+  }
 
   content::WebContentsImpl* web_contents_impl =
       static_cast<content::WebContentsImpl*>(web_contents_);
 
-  if (!web_contents_impl)
+  if (!web_contents_impl) {
     return;
+  }
 
   ui::AXMode accMode;
   // In windowless mode set accessibility to TreeOnly mode. Else native
@@ -337,8 +347,9 @@ bool CefBrowserPlatformDelegateAlloy::IsPrintPreviewSupported() const {
   REQUIRE_ALLOY_RUNTIME();
 
   // Print preview is not currently supported with OSR.
-  if (IsWindowless())
+  if (IsWindowless()) {
     return false;
+  }
 
   auto cef_browser_context =
       CefBrowserContext::FromBrowserContext(web_contents_->GetBrowserContext());
@@ -349,8 +360,9 @@ void CefBrowserPlatformDelegateAlloy::Find(const CefString& searchText,
                                            bool forward,
                                            bool matchCase,
                                            bool findNext) {
-  if (!web_contents_)
+  if (!web_contents_) {
     return;
+  }
 
   find_in_page::FindTabHelper::FromWebContents(web_contents_)
       ->StartFinding(searchText.ToString16(), forward, matchCase, findNext,
@@ -358,8 +370,9 @@ void CefBrowserPlatformDelegateAlloy::Find(const CefString& searchText,
 }
 
 void CefBrowserPlatformDelegateAlloy::StopFinding(bool clearSelection) {
-  if (!web_contents_)
+  if (!web_contents_) {
     return;
+  }
 
   last_search_result_ = find_in_page::FindNotificationDetails();
   find_in_page::FindTabHelper::FromWebContents(web_contents_)
@@ -373,8 +386,9 @@ bool CefBrowserPlatformDelegateAlloy::HandleFindReply(
     const gfx::Rect& selection_rect,
     int active_match_ordinal,
     bool final_update) {
-  if (!web_contents_)
+  if (!web_contents_) {
     return false;
+  }
 
   auto find_in_page =
       find_in_page::FindTabHelper::FromWebContents(web_contents_);
@@ -407,8 +421,9 @@ void CefBrowserPlatformDelegateAlloy::SetOwnedWebContents(
 }
 
 void CefBrowserPlatformDelegateAlloy::DestroyExtensionHost() {
-  if (!extension_host_)
+  if (!extension_host_) {
     return;
+  }
   if (extension_host_->extension_host_type() ==
       extensions::mojom::ViewType::kExtensionBackgroundPage) {
     DCHECK(is_background_host_);
diff --git a/libcef/browser/alloy/chrome_browser_process_alloy.cc b/libcef/browser/alloy/chrome_browser_process_alloy.cc
index a737c70b0..e343cda61 100644
--- a/libcef/browser/alloy/chrome_browser_process_alloy.cc
+++ b/libcef/browser/alloy/chrome_browser_process_alloy.cc
@@ -114,8 +114,9 @@ void ChromeBrowserProcessAlloy::CleanupOnUIThread() {
     // Release any references to |local_state_|.
     auto profile = browser_context->AsProfile();
     PrefWatcher* pref_watcher = PrefWatcher::Get(profile);
-    if (pref_watcher)
+    if (pref_watcher) {
       pref_watcher->Shutdown();
+    }
 
     // Unregister observers for |background_printing_manager_|.
     if (background_printing_manager_) {
@@ -345,8 +346,9 @@ void ChromeBrowserProcessAlloy::StartAutoupdateTimer() {}
 
 component_updater::ComponentUpdateService*
 ChromeBrowserProcessAlloy::component_updater() {
-  if (component_updater_)
+  if (component_updater_) {
     return component_updater_.get();
+  }
 
   if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
     return nullptr;
diff --git a/libcef/browser/alloy/chrome_profile_alloy.cc b/libcef/browser/alloy/chrome_profile_alloy.cc
index 58f5cc3ab..7e5b3c0d0 100644
--- a/libcef/browser/alloy/chrome_profile_alloy.cc
+++ b/libcef/browser/alloy/chrome_profile_alloy.cc
@@ -61,8 +61,9 @@ const Profile::OTRProfileID& ChromeProfileAlloy::GetOTRProfileID() const {
 }
 
 variations::VariationsClient* ChromeProfileAlloy::GetVariationsClient() {
-  if (!variations_client_)
+  if (!variations_client_) {
     variations_client_ = std::make_unique<CefVariationsClient>(this);
+  }
   return variations_client_.get();
 }
 
diff --git a/libcef/browser/alloy/chrome_profile_manager_alloy.cc b/libcef/browser/alloy/chrome_profile_manager_alloy.cc
index a2a757b69..8a577f5c5 100644
--- a/libcef/browser/alloy/chrome_profile_manager_alloy.cc
+++ b/libcef/browser/alloy/chrome_profile_manager_alloy.cc
@@ -51,8 +51,9 @@ Profile* ChromeProfileManagerAlloy::GetProfile(
 }
 
 bool ChromeProfileManagerAlloy::IsValidProfile(const void* profile) {
-  if (!profile)
+  if (!profile) {
     return false;
+  }
   return !!CefBrowserContext::FromBrowserContext(
       static_cast<const content::BrowserContext*>(profile));
 }
diff --git a/libcef/browser/alloy/dialogs/alloy_web_contents_dialog_helper.cc b/libcef/browser/alloy/dialogs/alloy_web_contents_dialog_helper.cc
index 3ba919907..402ce1725 100644
--- a/libcef/browser/alloy/dialogs/alloy_web_contents_dialog_helper.cc
+++ b/libcef/browser/alloy/dialogs/alloy_web_contents_dialog_helper.cc
@@ -81,8 +81,9 @@ gfx::Size AlloyWebContentsDialogHelper::GetMaximumDialogSize() {
 
 void AlloyWebContentsDialogHelper::AddObserver(
     web_modal::ModalDialogHostObserver* observer) {
-  if (observer && !observer_list_.HasObserver(observer))
+  if (observer && !observer_list_.HasObserver(observer)) {
     observer_list_.AddObserver(observer);
+  }
 }
 
 void AlloyWebContentsDialogHelper::RemoveObserver(
@@ -91,6 +92,7 @@ void AlloyWebContentsDialogHelper::RemoveObserver(
 }
 
 void AlloyWebContentsDialogHelper::OnBoundsChanged() {
-  for (auto& observer : observer_list_)
+  for (auto& observer : observer_list_) {
     observer.OnPositionRequiresUpdate();
+  }
 }
diff --git a/libcef/browser/audio_capturer.cc b/libcef/browser/audio_capturer.cc
index 3ed90421f..ce7625083 100644
--- a/libcef/browser/audio_capturer.cc
+++ b/libcef/browser/audio_capturer.cc
@@ -120,10 +120,12 @@ void CefAudioCapturer::OnCaptureError(
 }
 
 void CefAudioCapturer::StopStream() {
-  if (audio_input_device_)
+  if (audio_input_device_) {
     audio_input_device_->Stop();
-  if (capturing_)
+  }
+  if (capturing_) {
     audio_handler_->OnAudioStreamStopped(browser_);
+  }
 
   audio_input_device_ = nullptr;
   capturing_ = false;
diff --git a/libcef/browser/browser_contents_delegate.cc b/libcef/browser/browser_contents_delegate.cc
index 0200b51c1..b536fc7a5 100644
--- a/libcef/browser/browser_contents_delegate.cc
+++ b/libcef/browser/browser_contents_delegate.cc
@@ -130,8 +130,9 @@ content::WebContents* CefBrowserContentsDelegate::OpenURLFromTab(
     if (auto handler = c->GetRequestHandler()) {
       // May return nullptr for omnibox navigations.
       auto frame = browser()->GetFrame(params.frame_tree_node_id);
-      if (!frame)
+      if (!frame) {
         frame = browser()->GetMainFrame();
+      }
       cancel = handler->OnOpenURLFromTab(
           browser(), frame, params.url.spec(),
           static_cast<cef_window_open_disposition_t>(params.disposition),
@@ -283,8 +284,9 @@ bool CefBrowserContentsDelegate::HandleKeyboardEvent(
     content::WebContents* source,
     const content::NativeWebKeyboardEvent& event) {
   // Check to see if event should be ignored.
-  if (event.skip_in_browser)
+  if (event.skip_in_browser) {
     return false;
+  }
 
   if (auto delegate = platform_delegate()) {
     if (auto c = client()) {
@@ -368,14 +370,15 @@ void CefBrowserContentsDelegate::RenderViewReady() {
 void CefBrowserContentsDelegate::PrimaryMainFrameRenderProcessGone(
     base::TerminationStatus status) {
   cef_termination_status_t ts = TS_ABNORMAL_TERMINATION;
-  if (status == base::TERMINATION_STATUS_PROCESS_WAS_KILLED)
+  if (status == base::TERMINATION_STATUS_PROCESS_WAS_KILLED) {
     ts = TS_PROCESS_WAS_KILLED;
-  else if (status == base::TERMINATION_STATUS_PROCESS_CRASHED)
+  } else if (status == base::TERMINATION_STATUS_PROCESS_CRASHED) {
     ts = TS_PROCESS_CRASHED;
-  else if (status == base::TERMINATION_STATUS_OOM)
+  } else if (status == base::TERMINATION_STATUS_OOM) {
     ts = TS_PROCESS_OOM;
-  else if (status != base::TERMINATION_STATUS_ABNORMAL_TERMINATION)
+  } else if (status != base::TERMINATION_STATUS_ABNORMAL_TERMINATION) {
     return;
+  }
 
   if (auto c = client()) {
     if (auto handler = c->GetRequestHandler()) {
@@ -389,14 +392,16 @@ void CefBrowserContentsDelegate::OnFrameFocused(
     content::RenderFrameHost* render_frame_host) {
   CefRefPtr<CefFrameHostImpl> frame = static_cast<CefFrameHostImpl*>(
       browser_info_->GetFrameForHost(render_frame_host).get());
-  if (!frame || frame->IsFocused())
+  if (!frame || frame->IsFocused()) {
     return;
+  }
 
   CefRefPtr<CefFrameHostImpl> previous_frame = focused_frame_;
-  if (frame->IsMain())
+  if (frame->IsMain()) {
     focused_frame_ = nullptr;
-  else
+  } else {
     focused_frame_ = frame;
+  }
 
   if (!previous_frame) {
     // The main frame is focused by default.
@@ -449,8 +454,9 @@ void CefBrowserContentsDelegate::DidFinishNavigation(
 
   // Skip calls where the navigation has not yet committed and there is no
   // error code. For example, when creating a browser without loading a URL.
-  if (!navigation_handle->HasCommitted() && error_code == net::OK)
+  if (!navigation_handle->HasCommitted() && error_code == net::OK) {
     return;
+  }
 
   const bool is_main_frame = navigation_handle->IsInMainFrame();
   const auto global_id = frame_util::GetGlobalId(navigation_handle);
@@ -532,10 +538,11 @@ void CefBrowserContentsDelegate::DidFinishLoad(
 void CefBrowserContentsDelegate::TitleWasSet(content::NavigationEntry* entry) {
   // |entry| may be NULL if a popup is created via window.open and never
   // navigated.
-  if (entry)
+  if (entry) {
     OnTitleChange(entry->GetTitle());
-  else if (web_contents())
+  } else if (web_contents()) {
     OnTitleChange(web_contents()->GetTitle());
+  }
 }
 
 void CefBrowserContentsDelegate::DidUpdateFaviconURL(
@@ -594,8 +601,9 @@ void CefBrowserContentsDelegate::Observe(
 bool CefBrowserContentsDelegate::OnSetFocus(cef_focus_source_t source) {
   // SetFocus() might be called while inside the OnSetFocus() callback. If
   // so, don't re-enter the callback.
-  if (is_in_onsetfocus_)
+  if (is_in_onsetfocus_) {
     return true;
+  }
 
   if (auto c = client()) {
     if (auto handler = c->GetFocusHandler()) {
@@ -624,8 +632,9 @@ CefRefPtr<CefBrowser> CefBrowserContentsDelegate::browser() const {
 CefBrowserPlatformDelegate* CefBrowserContentsDelegate::platform_delegate()
     const {
   auto browser = browser_info_->browser();
-  if (browser)
+  if (browser) {
     return browser->platform_delegate();
+  }
   return nullptr;
 }
 
@@ -686,8 +695,9 @@ void CefBrowserContentsDelegate::OnTitleChange(const std::u16string& title) {
 }
 
 void CefBrowserContentsDelegate::OnFullscreenModeChange(bool fullscreen) {
-  if (fullscreen == is_fullscreen_)
+  if (fullscreen == is_fullscreen_) {
     return;
+  }
 
   is_fullscreen_ = fullscreen;
   OnStateChanged(State::kFullscreen);
diff --git a/libcef/browser/browser_context.cc b/libcef/browser/browser_context.cc
index 0fcc1abe9..6d91e32f7 100644
--- a/libcef/browser/browser_context.cc
+++ b/libcef/browser/browser_context.cc
@@ -64,8 +64,9 @@ class ImplManager {
     if (!path.empty()) {
       PathMap::iterator it = map_.find(path);
       DCHECK(it != map_.end());
-      if (it != map_.end())
+      if (it != map_.end()) {
         map_.erase(it);
+      }
     }
   }
 
@@ -89,12 +90,14 @@ class ImplManager {
   CefBrowserContext* GetImplFromBrowserContext(
       const content::BrowserContext* context) {
     CEF_REQUIRE_UIT();
-    if (!context)
+    if (!context) {
       return nullptr;
+    }
 
     for (const auto& bc : all_) {
-      if (bc->AsBrowserContext() == context)
+      if (bc->AsBrowserContext() == context) {
         return bc;
+      }
     }
     return nullptr;
   }
@@ -111,8 +114,9 @@ class ImplManager {
     CEF_REQUIRE_UIT();
     DCHECK(!path.empty());
     PathMap::const_iterator it = map_.find(path);
-    if (it != map_.end())
+    if (it != map_.end()) {
       return it->second;
+    }
     return nullptr;
   }
 
@@ -122,8 +126,9 @@ class ImplManager {
   Vector::iterator GetImplPos(const CefBrowserContext* impl) {
     Vector::iterator it = all_.begin();
     for (; it != all_.end(); ++it) {
-      if (*it == impl)
+      if (*it == impl) {
         return it;
+      }
     }
     return all_.end();
   }
@@ -187,8 +192,9 @@ CefBrowserContext::~CefBrowserContext() {
 void CefBrowserContext::Initialize() {
   cache_path_ = base::FilePath(CefString(&settings_.cache_path));
 
-  if (!cache_path_.empty())
+  if (!cache_path_.empty()) {
     g_manager.Get().SetImplPath(this, cache_path_);
+  }
 
   iothread_state_ = base::MakeRefCounted<CefIOThreadState>();
 
@@ -262,8 +268,9 @@ CefBrowserContext* CefBrowserContext::FromBrowserContext(
 // static
 CefBrowserContext* CefBrowserContext::FromProfile(const Profile* profile) {
   auto* cef_context = FromBrowserContext(profile);
-  if (cef_context)
+  if (cef_context) {
     return cef_context;
+  }
 
   if (cef::IsChromeRuntimeEnabled()) {
     auto* original_profile = profile->GetOriginalProfile();
@@ -311,8 +318,9 @@ void CefBrowserContext::OnRenderFrameDeleted(
   DCHECK(frame_util::IsValidGlobalId(global_id));
 
   auto it1 = render_id_set_.find(global_id);
-  if (it1 != render_id_set_.end())
+  if (it1 != render_id_set_.end()) {
     render_id_set_.erase(it1);
+  }
 
   CefRefPtr<CefRequestContextHandler> handler = request_context->GetHandler();
   if (handler) {
@@ -337,15 +345,17 @@ bool CefBrowserContext::IsAssociatedContext(
 
   if (frame_util::IsValidGlobalId(global_id)) {
     const auto it1 = render_id_set_.find(global_id);
-    if (it1 != render_id_set_.end())
+    if (it1 != render_id_set_.end()) {
       return true;
+    }
   }
 
   if (frame_util::IsValidChildId(global_id.child_id) && !require_frame_match) {
     // Choose an arbitrary handler for the same process.
     for (const auto& render_ids : render_id_set_) {
-      if (render_ids.child_id == global_id.child_id)
+      if (render_ids.child_id == global_id.child_id) {
         return true;
+      }
     }
   }
 
@@ -374,8 +384,9 @@ void CefBrowserContext::LoadExtension(
     CefRefPtr<CefExtensionHandler> handler,
     CefRefPtr<CefRequestContext> loader_context) {
   NOTIMPLEMENTED();
-  if (handler)
+  if (handler) {
     handler->OnExtensionLoadFailed(ERR_ABORTED);
+  }
 }
 
 bool CefBrowserContext::GetExtensions(std::vector<CefString>& extension_ids) {
@@ -415,8 +426,9 @@ CefMediaRouterManager* CefBrowserContext::GetMediaRouterManager() {
 CefBrowserContext::CookieableSchemes CefBrowserContext::GetCookieableSchemes()
     const {
   CEF_REQUIRE_UIT();
-  if (cookieable_schemes_)
+  if (cookieable_schemes_) {
     return cookieable_schemes_;
+  }
 
   return GetGlobalCookieableSchemes();
 }
diff --git a/libcef/browser/browser_host_base.cc b/libcef/browser/browser_host_base.cc
index 70b06a4f8..990be9722 100644
--- a/libcef/browser/browser_host_base.cc
+++ b/libcef/browser/browser_host_base.cc
@@ -50,8 +50,9 @@ class WebContentsUserDataAdapter : public base::SupportsUserData::Data {
     WebContentsUserDataAdapter* adapter =
         static_cast<WebContentsUserDataAdapter*>(
             web_contents->GetUserData(UserDataKey()));
-    if (adapter)
+    if (adapter) {
       return adapter->browser_;
+    }
     return nullptr;
   }
 
@@ -82,8 +83,9 @@ CefRefPtr<CefBrowserHostBase> CefBrowserHostBase::GetBrowserForHost(
   CEF_REQUIRE_UIT();
   content::WebContents* web_contents = content::WebContents::FromRenderViewHost(
       const_cast<content::RenderViewHost*>(host));
-  if (web_contents)
+  if (web_contents) {
     return GetBrowserForContents(web_contents);
+  }
   return nullptr;
 }
 
@@ -95,8 +97,9 @@ CefRefPtr<CefBrowserHostBase> CefBrowserHostBase::GetBrowserForHost(
   content::WebContents* web_contents =
       content::WebContents::FromRenderFrameHost(
           const_cast<content::RenderFrameHost*>(host));
-  if (web_contents)
+  if (web_contents) {
     return GetBrowserForContents(web_contents);
+  }
   return nullptr;
 }
 
@@ -119,8 +122,9 @@ CefRefPtr<CefBrowserHostBase> CefBrowserHostBase::GetBrowserForGlobalId(
     // Use the non-thread-safe but potentially faster approach.
     content::RenderFrameHost* render_frame_host =
         content::RenderFrameHost::FromID(global_id);
-    if (!render_frame_host)
+    if (!render_frame_host) {
       return nullptr;
+    }
     return GetBrowserForHost(render_frame_host);
   } else {
     // Use the thread-safe approach.
@@ -150,8 +154,9 @@ CefBrowserHostBase::GetBrowserForTopLevelNativeWindow(
   for (const auto& browser_info :
        CefBrowserInfoManager::GetInstance()->GetBrowserInfoList()) {
     if (auto browser = browser_info->browser()) {
-      if (browser->GetTopLevelNativeWindow() == owning_window)
+      if (browser->GetTopLevelNativeWindow() == owning_window) {
         return browser;
+      }
     }
   }
 
@@ -165,8 +170,9 @@ CefRefPtr<CefBrowserHostBase> CefBrowserHostBase::GetLikelyFocusedBrowser() {
   for (const auto& browser_info :
        CefBrowserInfoManager::GetInstance()->GetBrowserInfoList()) {
     if (auto browser = browser_info->browser()) {
-      if (browser->IsFocused())
+      if (browser->IsFocused()) {
         return browser;
+      }
     }
   }
 
@@ -240,10 +246,11 @@ void CefBrowserHostBase::SetFocus(bool focus) {
     return;
   }
 
-  if (focus)
+  if (focus) {
     OnSetFocus(FOCUS_SOURCE_SYSTEM);
-  else if (platform_delegate_)
+  } else if (platform_delegate_) {
     platform_delegate_->SetFocus(false);
+  }
 }
 
 void CefBrowserHostBase::RunFileDialog(
@@ -262,8 +269,9 @@ void CefBrowserHostBase::RunFileDialog(
 
   if (!callback || !EnsureFileDialogManager()) {
     LOG(ERROR) << "File dialog canceled due to invalid state.";
-    if (callback)
+    if (callback) {
       callback->OnFileDialogDismissed({});
+    }
     return;
   }
 
@@ -279,20 +287,24 @@ void CefBrowserHostBase::StartDownload(const CefString& url) {
   }
 
   GURL gurl = GURL(url.ToString());
-  if (gurl.is_empty() || !gurl.is_valid())
+  if (gurl.is_empty() || !gurl.is_valid()) {
     return;
+  }
 
   auto web_contents = GetWebContents();
-  if (!web_contents)
+  if (!web_contents) {
     return;
+  }
 
   auto browser_context = web_contents->GetBrowserContext();
-  if (!browser_context)
+  if (!browser_context) {
     return;
+  }
 
   content::DownloadManager* manager = browser_context->GetDownloadManager();
-  if (!manager)
+  if (!manager) {
     return;
+  }
 
   std::unique_ptr<download::DownloadUrlParameters> params(
       content::DownloadRequestUtils::CreateDownloadForWebContentsMainFrame(
@@ -314,16 +326,19 @@ void CefBrowserHostBase::DownloadImage(
     return;
   }
 
-  if (!callback)
+  if (!callback) {
     return;
+  }
 
   GURL gurl = GURL(image_url.ToString());
-  if (gurl.is_empty() || !gurl.is_valid())
+  if (gurl.is_empty() || !gurl.is_valid()) {
     return;
+  }
 
   auto web_contents = GetWebContents();
-  if (!web_contents)
+  if (!web_contents) {
     return;
+  }
 
   web_contents->DownloadImage(
       gurl, is_favicon, gfx::Size(max_image_size, max_image_size),
@@ -356,8 +371,9 @@ void CefBrowserHostBase::Print() {
   }
 
   auto web_contents = GetWebContents();
-  if (!web_contents)
+  if (!web_contents) {
     return;
+  }
 
   const bool print_preview_disabled =
       !platform_delegate_ || !platform_delegate_->IsPrintPreviewSupported();
@@ -374,16 +390,18 @@ void CefBrowserHostBase::PrintToPDF(const CefString& path,
   }
 
   auto web_contents = GetWebContents();
-  if (!web_contents)
+  if (!web_contents) {
     return;
+  }
 
   print_util::PrintToPDF(web_contents, path, settings, callback);
 }
 
 bool CefBrowserHostBase::SendDevToolsMessage(const void* message,
                                              size_t message_size) {
-  if (!message || message_size == 0)
+  if (!message || message_size == 0) {
     return false;
+  }
 
   if (!CEF_CURRENTLY_ON_UIT()) {
     std::string message_str(static_cast<const char*>(message), message_size);
@@ -397,8 +415,9 @@ bool CefBrowserHostBase::SendDevToolsMessage(const void* message,
     return false;
   }
 
-  if (!EnsureDevToolsManager())
+  if (!EnsureDevToolsManager()) {
     return false;
+  }
   return devtools_manager_->SendDevToolsMessage(message, message_size);
 }
 
@@ -414,15 +433,17 @@ int CefBrowserHostBase::ExecuteDevToolsMethod(
     return 0;
   }
 
-  if (!EnsureDevToolsManager())
+  if (!EnsureDevToolsManager()) {
     return 0;
+  }
   return devtools_manager_->ExecuteDevToolsMethod(message_id, method, params);
 }
 
 CefRefPtr<CefRegistration> CefBrowserHostBase::AddDevToolsMessageObserver(
     CefRefPtr<CefDevToolsMessageObserver> observer) {
-  if (!observer)
+  if (!observer) {
     return nullptr;
+  }
   auto registration = CefDevToolsManager::CreateRegistration(observer);
   InitializeDevToolsRegistrationOnUIThread(registration);
   return registration.get();
@@ -432,8 +453,9 @@ void CefBrowserHostBase::GetNavigationEntries(
     CefRefPtr<CefNavigationEntryVisitor> visitor,
     bool current_only) {
   DCHECK(visitor.get());
-  if (!visitor.get())
+  if (!visitor.get()) {
     return;
+  }
 
   if (!CEF_CURRENTLY_ON_UIT()) {
     CEF_POST_TASK(
@@ -443,8 +465,9 @@ void CefBrowserHostBase::GetNavigationEntries(
   }
 
   auto web_contents = GetWebContents();
-  if (!web_contents)
+  if (!web_contents) {
     return;
+  }
 
   content::NavigationController& controller = web_contents->GetController();
   const int total = controller.GetEntryCount();
@@ -476,11 +499,13 @@ CefRefPtr<CefNavigationEntry> CefBrowserHostBase::GetVisibleNavigationEntry() {
 
   content::NavigationEntry* entry = nullptr;
   auto web_contents = GetWebContents();
-  if (web_contents)
+  if (web_contents) {
     entry = web_contents->GetController().GetVisibleEntry();
+  }
 
-  if (!entry)
+  if (!entry) {
     return nullptr;
+  }
 
   return new CefNavigationEntryImpl(entry);
 }
@@ -494,8 +519,9 @@ void CefBrowserHostBase::NotifyMoveOrResizeStarted() {
     return;
   }
 
-  if (platform_delegate_)
+  if (platform_delegate_) {
     platform_delegate_->NotifyMoveOrResizeStarted();
+  }
 #endif
 }
 
@@ -508,8 +534,9 @@ void CefBrowserHostBase::ReplaceMisspelling(const CefString& word) {
   }
 
   auto web_contents = GetWebContents();
-  if (web_contents)
+  if (web_contents) {
     web_contents->ReplaceMisspelling(word);
+  }
 }
 
 void CefBrowserHostBase::AddWordToDictionary(const CefString& word) {
@@ -521,15 +548,17 @@ void CefBrowserHostBase::AddWordToDictionary(const CefString& word) {
   }
 
   auto web_contents = GetWebContents();
-  if (!web_contents)
+  if (!web_contents) {
     return;
+  }
 
   SpellcheckService* spellcheck = nullptr;
   content::BrowserContext* browser_context = web_contents->GetBrowserContext();
   if (browser_context) {
     spellcheck = SpellcheckServiceFactory::GetForContext(browser_context);
-    if (spellcheck)
+    if (spellcheck) {
       spellcheck->GetCustomDictionary()->AddWord(word);
+    }
   }
 #if BUILDFLAG(IS_MAC)
   if (spellcheck && spellcheck::UseBrowserSpellChecker()) {
@@ -545,8 +574,9 @@ void CefBrowserHostBase::SendKeyEvent(const CefKeyEvent& event) {
     return;
   }
 
-  if (platform_delegate_)
+  if (platform_delegate_) {
     platform_delegate_->SendKeyEvent(event);
+  }
 }
 
 void CefBrowserHostBase::SendMouseClickEvent(const CefMouseEvent& event,
@@ -753,8 +783,9 @@ CefRefPtr<CefFrame> CefBrowserHostBase::GetFrame(int64 identifier) {
 
 CefRefPtr<CefFrame> CefBrowserHostBase::GetFrame(const CefString& name) {
   for (const auto& frame : browser_info_->GetAllFrames()) {
-    if (frame->GetName() == name)
+    if (frame->GetName() == name) {
       return frame;
+    }
   }
   return nullptr;
 }
@@ -764,12 +795,14 @@ size_t CefBrowserHostBase::GetFrameCount() {
 }
 
 void CefBrowserHostBase::GetFrameIdentifiers(std::vector<int64>& identifiers) {
-  if (identifiers.size() > 0)
+  if (identifiers.size() > 0) {
     identifiers.clear();
+  }
 
   const auto frames = browser_info_->GetAllFrames();
-  if (frames.empty())
+  if (frames.empty()) {
     return;
+  }
 
   identifiers.reserve(frames.size());
   for (const auto& frame : frames) {
@@ -778,12 +811,14 @@ void CefBrowserHostBase::GetFrameIdentifiers(std::vector<int64>& identifiers) {
 }
 
 void CefBrowserHostBase::GetFrameNames(std::vector<CefString>& names) {
-  if (names.size() > 0)
+  if (names.size() > 0) {
     names.clear();
+  }
 
   const auto frames = browser_info_->GetAllFrames();
-  if (frames.empty())
+  if (frames.empty()) {
     return;
+  }
 
   names.reserve(frames.size());
   for (const auto& frame : frames) {
@@ -821,8 +856,9 @@ void CefBrowserHostBase::OnWebContentsDestroyed(
 CefRefPtr<CefFrame> CefBrowserHostBase::GetFrameForHost(
     const content::RenderFrameHost* host) {
   CEF_REQUIRE_UIT();
-  if (!host)
+  if (!host) {
     return nullptr;
+  }
 
   return browser_info_->GetFrameForHost(host);
 }
@@ -870,8 +906,9 @@ bool CefBrowserHostBase::Navigate(const content::OpenURLParams& params) {
   auto web_contents = GetWebContents();
   if (web_contents) {
     GURL gurl = params.url;
-    if (!url_util::FixupGURL(gurl))
+    if (!url_util::FixupGURL(gurl)) {
       return false;
+    }
 
     web_contents->GetController().LoadURL(
         gurl, params.referrer, params.transition, params.extra_headers);
@@ -887,8 +924,9 @@ void CefBrowserHostBase::ViewText(const std::string& text) {
     return;
   }
 
-  if (platform_delegate_)
+  if (platform_delegate_) {
     platform_delegate_->ViewText(text);
+  }
 }
 
 void CefBrowserHostBase::RunFileChooserForBrowser(
@@ -965,8 +1003,9 @@ void CefBrowserHostBase::OnBrowserDestroyed() {
     file_dialog_manager_.reset();
   }
 
-  for (auto& observer : observers_)
+  for (auto& observer : observers_) {
     observer.OnBrowserDestroyed(this);
+  }
 }
 
 int CefBrowserHostBase::browser_id() const {
@@ -991,8 +1030,9 @@ content::WebContents* CefBrowserHostBase::GetWebContents() const {
 content::BrowserContext* CefBrowserHostBase::GetBrowserContext() const {
   CEF_REQUIRE_UIT();
   auto web_contents = GetWebContents();
-  if (web_contents)
+  if (web_contents) {
     return web_contents->GetBrowserContext();
+  }
   return nullptr;
 }
 
@@ -1006,15 +1046,17 @@ CefMediaStreamRegistrar* CefBrowserHostBase::GetMediaStreamRegistrar() {
 
 views::Widget* CefBrowserHostBase::GetWindowWidget() const {
   CEF_REQUIRE_UIT();
-  if (!platform_delegate_)
+  if (!platform_delegate_) {
     return nullptr;
+  }
   return platform_delegate_->GetWindowWidget();
 }
 
 CefRefPtr<CefBrowserView> CefBrowserHostBase::GetBrowserView() const {
   CEF_REQUIRE_UIT();
-  if (is_views_hosted_ && platform_delegate_)
+  if (is_views_hosted_ && platform_delegate_) {
     return platform_delegate_->GetBrowserView();
+  }
   return nullptr;
 }
 
@@ -1055,8 +1097,9 @@ bool CefBrowserHostBase::IsVisible() const {
 
 bool CefBrowserHostBase::EnsureDevToolsManager() {
   CEF_REQUIRE_UIT();
-  if (!contents_delegate_->web_contents())
+  if (!contents_delegate_->web_contents()) {
     return false;
+  }
 
   if (!devtools_manager_) {
     devtools_manager_ = std::make_unique<CefDevToolsManager>(this);
@@ -1075,15 +1118,17 @@ void CefBrowserHostBase::InitializeDevToolsRegistrationOnUIThread(
     return;
   }
 
-  if (!EnsureDevToolsManager())
+  if (!EnsureDevToolsManager()) {
     return;
+  }
   devtools_manager_->InitializeRegistrationOnUIThread(registration);
 }
 
 bool CefBrowserHostBase::EnsureFileDialogManager() {
   CEF_REQUIRE_UIT();
-  if (!contents_delegate_->web_contents())
+  if (!contents_delegate_->web_contents()) {
     return false;
+  }
 
   if (!file_dialog_manager_) {
     file_dialog_manager_ = std::make_unique<CefFileDialogManager>(this);
diff --git a/libcef/browser/browser_host_base.h b/libcef/browser/browser_host_base.h
index a14b27454..982812932 100644
--- a/libcef/browser/browser_host_base.h
+++ b/libcef/browser/browser_host_base.h
@@ -41,8 +41,9 @@ struct CefBrowserCreateParams {
     settings = that.settings;
     request_context = that.request_context;
     extra_info = that.extra_info;
-    if (that.window_info)
+    if (that.window_info) {
       MaybeSetWindowInfo(*that.window_info);
+    }
     browser_view = that.browser_view;
     return *this;
   }
diff --git a/libcef/browser/browser_info.cc b/libcef/browser/browser_info.cc
index 0128ddfbb..1b6f5ffb3 100644
--- a/libcef/browser/browser_info.cc
+++ b/libcef/browser/browser_info.cc
@@ -41,8 +41,9 @@ CefBrowserInfo::~CefBrowserInfo() {
 
 CefRefPtr<CefBrowserHostBase> CefBrowserInfo::browser() const {
   base::AutoLock lock_scope(lock_);
-  if (!is_closing_)
+  if (!is_closing_) {
     return browser_;
+  }
   return nullptr;
 }
 
@@ -189,8 +190,9 @@ void CefBrowserInfo::FrameHostStateChanged(
   bool removed_from_bfcache =
       old_state ==
       content::RenderFrameHost::LifecycleState::kInBackForwardCache;
-  if (!added_to_bfcache && !removed_from_bfcache)
+  if (!added_to_bfcache && !removed_from_bfcache) {
     return;
+  }
 
   base::AutoLock lock_scope(lock_);
 
@@ -238,8 +240,9 @@ void CefBrowserInfo::RemoveFrame(content::RenderFrameHost* host) {
 CefRefPtr<CefFrameHostImpl> CefBrowserInfo::GetMainFrame() {
   base::AutoLock lock_scope(lock_);
   // Early exit if called post-destruction.
-  if (!browser_ || is_closing_)
+  if (!browser_ || is_closing_) {
     return nullptr;
+  }
 
   CHECK(main_frame_);
   return main_frame_;
@@ -248,8 +251,9 @@ CefRefPtr<CefFrameHostImpl> CefBrowserInfo::GetMainFrame() {
 CefRefPtr<CefFrameHostImpl> CefBrowserInfo::CreateTempSubFrame(
     const content::GlobalRenderFrameHostId& parent_global_id) {
   CefRefPtr<CefFrameHostImpl> parent = GetFrameForGlobalId(parent_global_id);
-  if (!parent)
+  if (!parent) {
     parent = GetMainFrame();
+  }
   // Intentionally not notifying for temporary frames.
   return new CefFrameHostImpl(this, parent->GetIdentifier());
 }
@@ -258,11 +262,13 @@ CefRefPtr<CefFrameHostImpl> CefBrowserInfo::GetFrameForHost(
     const content::RenderFrameHost* host,
     bool* is_guest_view,
     bool prefer_speculative) const {
-  if (is_guest_view)
+  if (is_guest_view) {
     *is_guest_view = false;
+  }
 
-  if (!host)
+  if (!host) {
     return nullptr;
+  }
 
   return GetFrameForGlobalId(
       const_cast<content::RenderFrameHost*>(host)->GetGlobalId(), is_guest_view,
@@ -273,11 +279,13 @@ CefRefPtr<CefFrameHostImpl> CefBrowserInfo::GetFrameForGlobalId(
     const content::GlobalRenderFrameHostId& global_id,
     bool* is_guest_view,
     bool prefer_speculative) const {
-  if (is_guest_view)
+  if (is_guest_view) {
     *is_guest_view = false;
+  }
 
-  if (!frame_util::IsValidGlobalId(global_id))
+  if (!frame_util::IsValidGlobalId(global_id)) {
     return nullptr;
+  }
 
   base::AutoLock lock_scope(lock_);
 
@@ -286,8 +294,9 @@ CefRefPtr<CefFrameHostImpl> CefBrowserInfo::GetFrameForGlobalId(
     const auto info = it->second;
 
     if (info->is_guest_view_) {
-      if (is_guest_view)
+      if (is_guest_view) {
         *is_guest_view = true;
+      }
       return nullptr;
     }
 
@@ -381,8 +390,9 @@ void CefBrowserInfo::MaybeNotifyDraggableRegionsChanged(
   CEF_REQUIRE_UIT();
   DCHECK(frame->IsMain());
 
-  if (draggable_regions == draggable_regions_)
+  if (draggable_regions == draggable_regions_) {
     return;
+  }
 
   draggable_regions_ = std::move(draggable_regions);
 
@@ -499,8 +509,9 @@ void CefBrowserInfo::RemoveAllFrames(
     }
   }
 
-  if (main_frame_)
+  if (main_frame_) {
     SetMainFrame(old_browser, nullptr);
+  }
 
   // And finally delete the frame info.
   frame_info_set_.clear();
diff --git a/libcef/browser/browser_info_manager.cc b/libcef/browser/browser_info_manager.cc
index 22fe1aa42..56a6a9b54 100644
--- a/libcef/browser/browser_info_manager.cc
+++ b/libcef/browser/browser_info_manager.cc
@@ -155,14 +155,18 @@ bool CefBrowserInfoManager::CanCreateWindow(
       TranslatePopupFeatures(features, cef_features);
 
       // Default to the size from the popup features.
-      if (cef_features.xSet)
+      if (cef_features.xSet) {
         window_info.bounds.x = cef_features.x;
-      if (cef_features.ySet)
+      }
+      if (cef_features.ySet) {
         window_info.bounds.y = cef_features.y;
-      if (cef_features.widthSet)
+      }
+      if (cef_features.widthSet) {
         window_info.bounds.width = cef_features.width;
-      if (cef_features.heightSet)
+      }
+      if (cef_features.heightSet) {
         window_info.bounds.height = cef_features.height;
+      }
 
       allow = !handler->OnBeforePopup(
           browser.get(), opener_frame, pending_popup->target_url.spec(),
@@ -463,19 +467,22 @@ scoped_refptr<CefBrowserInfo> CefBrowserInfoManager::GetBrowserInfoInternal(
     bool* is_guest_view) {
   browser_info_lock_.AssertAcquired();
 
-  if (is_guest_view)
+  if (is_guest_view) {
     *is_guest_view = false;
+  }
 
-  if (!frame_util::IsValidGlobalId(global_id))
+  if (!frame_util::IsValidGlobalId(global_id)) {
     return nullptr;
+  }
 
   for (const auto& browser_info : browser_info_list_) {
     bool is_guest_view_tmp;
     auto frame =
         browser_info->GetFrameForGlobalId(global_id, &is_guest_view_tmp);
     if (frame || is_guest_view_tmp) {
-      if (is_guest_view)
+      if (is_guest_view) {
         *is_guest_view = is_guest_view_tmp;
+      }
       return browser_info;
     }
   }
@@ -534,8 +541,9 @@ void CefBrowserInfoManager::TimeoutNewBrowserInfoResponse(
     const content::GlobalRenderFrameHostId& global_id,
     int timeout_id) {
   CEF_REQUIRE_UIT();
-  if (!g_info_manager)
+  if (!g_info_manager) {
     return;
+  }
 
   base::AutoLock lock_scope(g_info_manager->browser_info_lock_);
 
@@ -544,8 +552,9 @@ void CefBrowserInfoManager::TimeoutNewBrowserInfoResponse(
   if (it != g_info_manager->pending_new_browser_info_map_.end()) {
     const auto& pending_info = it->second;
     // Don't accidentally timeout a new request for the same frame.
-    if (pending_info->timeout_id != timeout_id)
+    if (pending_info->timeout_id != timeout_id) {
       return;
+    }
 
 #if DCHECK_IS_ON()
     // This method should never be called for a PDF renderer.
diff --git a/libcef/browser/browser_message_loop.cc b/libcef/browser/browser_message_loop.cc
index 8596d0463..92d924871 100644
--- a/libcef/browser/browser_message_loop.cc
+++ b/libcef/browser/browser_message_loop.cc
@@ -35,8 +35,9 @@ class MessagePumpExternal : public base::MessagePumpForUI {
 
       base::TimeTicks next_run_time;  // is_null()
       const bool has_more_work = DirectRunWork(delegate, &next_run_time);
-      if (!has_more_work)
+      if (!has_more_work) {
         break;
+      }
 
       if (next_run_time.is_null()) {
         // We have more work that should run immediately.
@@ -44,8 +45,9 @@ class MessagePumpExternal : public base::MessagePumpForUI {
       }
 
       const base::TimeDelta& delta = next_run_time - start;
-      if (delta.InSecondsF() > max_time_slice_)
+      if (delta.InSecondsF() > max_time_slice_) {
         break;
+      }
     }
   }
 
@@ -96,8 +98,9 @@ class MessagePumpExternal : public base::MessagePumpForUI {
 
 CefRefPtr<CefBrowserProcessHandler> GetBrowserProcessHandler() {
   CefRefPtr<CefApp> app = CefAppManager::Get()->GetApplication();
-  if (app)
+  if (app) {
     return app->GetBrowserProcessHandler();
+  }
   return nullptr;
 }
 
@@ -106,8 +109,9 @@ std::unique_ptr<base::MessagePump> MessagePumpFactoryForUI() {
           content::BrowserThread::UI) ||
       content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
     CefRefPtr<CefBrowserProcessHandler> handler = GetBrowserProcessHandler();
-    if (handler)
+    if (handler) {
       return std::make_unique<MessagePumpExternal>(0.01f, handler);
+    }
   }
 
 #if BUILDFLAG(IS_MAC)
diff --git a/libcef/browser/browser_platform_delegate.cc b/libcef/browser/browser_platform_delegate.cc
index 59c7c476f..e503ef7b0 100644
--- a/libcef/browser/browser_platform_delegate.cc
+++ b/libcef/browser/browser_platform_delegate.cc
@@ -67,8 +67,9 @@ void CefBrowserPlatformDelegate::RenderViewCreated(
     content::RenderViewHost* render_view_host) {
   // Indicate that the view has an external parent (namely us). This setting is
   // required for proper focus handling on Windows and Linux.
-  if (HasExternalParent() && render_view_host->GetWidget()->GetView())
+  if (HasExternalParent() && render_view_host->GetWidget()->GetView()) {
     render_view_host->GetWidget()->GetView()->SetHasExternalParent(true);
+  }
 }
 
 void CefBrowserPlatformDelegate::RenderViewReady() {}
@@ -367,8 +368,9 @@ gfx::Point CefBrowserPlatformDelegate::GetDialogPosition(
 }
 
 gfx::Size CefBrowserPlatformDelegate::GetMaximumDialogSize() {
-  if (!web_contents_)
+  if (!web_contents_) {
     return gfx::Size();
+  }
 
   // The dialog should try to fit within the overlay for the web contents.
   // Note that, for things like print preview, this is just a suggested maximum.
@@ -406,33 +408,47 @@ int CefBrowserPlatformDelegate::TranslateWebEventModifiers(
     uint32 cef_modifiers) {
   int result = 0;
   // Set modifiers based on key state.
-  if (cef_modifiers & EVENTFLAG_CAPS_LOCK_ON)
+  if (cef_modifiers & EVENTFLAG_CAPS_LOCK_ON) {
     result |= blink::WebInputEvent::kCapsLockOn;
-  if (cef_modifiers & EVENTFLAG_SHIFT_DOWN)
+  }
+  if (cef_modifiers & EVENTFLAG_SHIFT_DOWN) {
     result |= blink::WebInputEvent::kShiftKey;
-  if (cef_modifiers & EVENTFLAG_CONTROL_DOWN)
+  }
+  if (cef_modifiers & EVENTFLAG_CONTROL_DOWN) {
     result |= blink::WebInputEvent::kControlKey;
-  if (cef_modifiers & EVENTFLAG_ALT_DOWN)
+  }
+  if (cef_modifiers & EVENTFLAG_ALT_DOWN) {
     result |= blink::WebInputEvent::kAltKey;
-  if (cef_modifiers & EVENTFLAG_LEFT_MOUSE_BUTTON)
+  }
+  if (cef_modifiers & EVENTFLAG_LEFT_MOUSE_BUTTON) {
     result |= blink::WebInputEvent::kLeftButtonDown;
-  if (cef_modifiers & EVENTFLAG_MIDDLE_MOUSE_BUTTON)
+  }
+  if (cef_modifiers & EVENTFLAG_MIDDLE_MOUSE_BUTTON) {
     result |= blink::WebInputEvent::kMiddleButtonDown;
-  if (cef_modifiers & EVENTFLAG_RIGHT_MOUSE_BUTTON)
+  }
+  if (cef_modifiers & EVENTFLAG_RIGHT_MOUSE_BUTTON) {
     result |= blink::WebInputEvent::kRightButtonDown;
-  if (cef_modifiers & EVENTFLAG_COMMAND_DOWN)
+  }
+  if (cef_modifiers & EVENTFLAG_COMMAND_DOWN) {
     result |= blink::WebInputEvent::kMetaKey;
-  if (cef_modifiers & EVENTFLAG_NUM_LOCK_ON)
+  }
+  if (cef_modifiers & EVENTFLAG_NUM_LOCK_ON) {
     result |= blink::WebInputEvent::kNumLockOn;
-  if (cef_modifiers & EVENTFLAG_IS_KEY_PAD)
+  }
+  if (cef_modifiers & EVENTFLAG_IS_KEY_PAD) {
     result |= blink::WebInputEvent::kIsKeyPad;
-  if (cef_modifiers & EVENTFLAG_IS_LEFT)
+  }
+  if (cef_modifiers & EVENTFLAG_IS_LEFT) {
     result |= blink::WebInputEvent::kIsLeft;
-  if (cef_modifiers & EVENTFLAG_IS_RIGHT)
+  }
+  if (cef_modifiers & EVENTFLAG_IS_RIGHT) {
     result |= blink::WebInputEvent::kIsRight;
-  if (cef_modifiers & EVENTFLAG_ALTGR_DOWN)
+  }
+  if (cef_modifiers & EVENTFLAG_ALTGR_DOWN) {
     result |= blink::WebInputEvent::kAltGrKey;
-  if (cef_modifiers & EVENTFLAG_IS_REPEAT)
+  }
+  if (cef_modifiers & EVENTFLAG_IS_REPEAT) {
     result |= blink::WebInputEvent::kIsAutoRepeat;
+  }
   return result;
 }
diff --git a/libcef/browser/browser_util.cc b/libcef/browser/browser_util.cc
index 19a92ae8b..e7bddaf65 100644
--- a/libcef/browser/browser_util.cc
+++ b/libcef/browser/browser_util.cc
@@ -28,24 +28,33 @@ bool GetCefKeyEvent(const content::NativeWebKeyboardEvent& event,
   }
 
   cef_event.modifiers = 0;
-  if (event.GetModifiers() & blink::WebKeyboardEvent::kShiftKey)
+  if (event.GetModifiers() & blink::WebKeyboardEvent::kShiftKey) {
     cef_event.modifiers |= EVENTFLAG_SHIFT_DOWN;
-  if (event.GetModifiers() & blink::WebKeyboardEvent::kControlKey)
+  }
+  if (event.GetModifiers() & blink::WebKeyboardEvent::kControlKey) {
     cef_event.modifiers |= EVENTFLAG_CONTROL_DOWN;
-  if (event.GetModifiers() & blink::WebKeyboardEvent::kAltKey)
+  }
+  if (event.GetModifiers() & blink::WebKeyboardEvent::kAltKey) {
     cef_event.modifiers |= EVENTFLAG_ALT_DOWN;
-  if (event.GetModifiers() & blink::WebKeyboardEvent::kMetaKey)
+  }
+  if (event.GetModifiers() & blink::WebKeyboardEvent::kMetaKey) {
     cef_event.modifiers |= EVENTFLAG_COMMAND_DOWN;
-  if (event.GetModifiers() & blink::WebKeyboardEvent::kIsKeyPad)
+  }
+  if (event.GetModifiers() & blink::WebKeyboardEvent::kIsKeyPad) {
     cef_event.modifiers |= EVENTFLAG_IS_KEY_PAD;
-  if (event.GetModifiers() & blink::WebKeyboardEvent::kIsLeft)
+  }
+  if (event.GetModifiers() & blink::WebKeyboardEvent::kIsLeft) {
     cef_event.modifiers |= EVENTFLAG_IS_LEFT;
-  if (event.GetModifiers() & blink::WebKeyboardEvent::kIsRight)
+  }
+  if (event.GetModifiers() & blink::WebKeyboardEvent::kIsRight) {
     cef_event.modifiers |= EVENTFLAG_IS_RIGHT;
-  if (event.GetModifiers() & blink::WebKeyboardEvent::kAltGrKey)
+  }
+  if (event.GetModifiers() & blink::WebKeyboardEvent::kAltGrKey) {
     cef_event.modifiers |= EVENTFLAG_ALTGR_DOWN;
-  if (event.GetModifiers() & blink::WebKeyboardEvent::kIsAutoRepeat)
+  }
+  if (event.GetModifiers() & blink::WebKeyboardEvent::kIsAutoRepeat) {
     cef_event.modifiers |= EVENTFLAG_IS_REPEAT;
+  }
 
   cef_event.windows_key_code = event.windows_key_code;
   cef_event.native_key_code = event.native_key_code;
diff --git a/libcef/browser/chrome/browser_platform_delegate_chrome.cc b/libcef/browser/chrome/browser_platform_delegate_chrome.cc
index 0c9ccc808..e53eb4eef 100644
--- a/libcef/browser/chrome/browser_platform_delegate_chrome.cc
+++ b/libcef/browser/chrome/browser_platform_delegate_chrome.cc
@@ -140,8 +140,9 @@ void CefBrowserPlatformDelegateChrome::set_chrome_browser(Browser* browser) {
 }
 
 gfx::NativeWindow CefBrowserPlatformDelegateChrome::GetNativeWindow() const {
-  if (chrome_browser_ && chrome_browser_->window())
+  if (chrome_browser_ && chrome_browser_->window()) {
     return chrome_browser_->window()->GetNativeWindow();
+  }
   NOTREACHED();
   return gfx::NativeWindow();
 }
diff --git a/libcef/browser/chrome/chrome_browser_delegate.cc b/libcef/browser/chrome/chrome_browser_delegate.cc
index 6df40c319..70b696c38 100644
--- a/libcef/browser/chrome/chrome_browser_delegate.cc
+++ b/libcef/browser/chrome/chrome_browser_delegate.cc
@@ -234,8 +234,9 @@ void ChromeBrowserDelegate::EnterFullscreenModeForTab(
     const blink::mojom::FullscreenOptions& options) {
   auto web_contents =
       content::WebContents::FromRenderFrameHost(requesting_frame);
-  if (!web_contents)
+  if (!web_contents) {
     return;
+  }
 
   if (auto delegate = GetDelegateForWebContents(web_contents)) {
     delegate->EnterFullscreenModeForTab(requesting_frame, options);
@@ -334,8 +335,9 @@ CefBrowserContentsDelegate* ChromeBrowserDelegate::GetDelegateForWebContents(
     content::WebContents* web_contents) {
   auto browser_host =
       ChromeBrowserHostImpl::GetBrowserForContents(web_contents);
-  if (browser_host)
+  if (browser_host) {
     return browser_host->contents_delegate();
+  }
   return nullptr;
 }
 
diff --git a/libcef/browser/chrome/chrome_browser_host_impl.cc b/libcef/browser/chrome/chrome_browser_host_impl.cc
index cb6c362dc..17bbb7512 100644
--- a/libcef/browser/chrome/chrome_browser_host_impl.cc
+++ b/libcef/browser/chrome/chrome_browser_host_impl.cc
@@ -134,11 +134,13 @@ void ChromeBrowserHostImpl::OnSetFocus(cef_focus_source_t source) {
     return;
   }
 
-  if (contents_delegate_->OnSetFocus(source))
+  if (contents_delegate_->OnSetFocus(source)) {
     return;
+  }
 
-  if (platform_delegate_)
+  if (platform_delegate_) {
     platform_delegate_->SetFocus(true);
+  }
 
   if (browser_) {
     const int tab_index = GetCurrentTabIndex();
@@ -164,8 +166,9 @@ CefWindowHandle ChromeBrowserHostImpl::GetWindowHandle() {
   if (CEF_CURRENTLY_ON_UIT()) {
     // Always return the most up-to-date window handle for a views-hosted
     // browser since it may change if the view is re-parented.
-    if (platform_delegate_)
+    if (platform_delegate_) {
       return platform_delegate_->GetHostWindowHandle();
+    }
   }
   return host_window_handle_;
 }
@@ -337,8 +340,9 @@ bool ChromeBrowserHostImpl::Navigate(const content::OpenURLParams& params) {
 
   if (browser_) {
     GURL gurl = params.url;
-    if (!url_util::FixupGURL(gurl))
+    if (!url_util::FixupGURL(gurl)) {
       return false;
+    }
 
     // This is generally equivalent to calling Browser::OpenURL, except:
     // 1. It doesn't trigger a call to CefRequestHandler::OnOpenURLFromTab, and
@@ -354,8 +358,9 @@ bool ChromeBrowserHostImpl::Navigate(const content::OpenURLParams& params) {
     nav_params.source_contents = GetWebContents();
 
     nav_params.tabstrip_add_types = AddTabTypes::ADD_NONE;
-    if (params.user_gesture)
+    if (params.user_gesture) {
       nav_params.window_action = NavigateParams::SHOW_WINDOW;
+    }
     ::Navigate(&nav_params);
     return true;
   }
@@ -498,8 +503,9 @@ void ChromeBrowserHostImpl::SetBrowser(Browser* browser) {
   browser_ = browser;
   static_cast<CefBrowserPlatformDelegateChrome*>(platform_delegate_.get())
       ->set_chrome_browser(browser);
-  if (browser_)
+  if (browser_) {
     host_window_handle_ = platform_delegate_->GetHostWindowHandle();
+  }
 }
 
 void ChromeBrowserHostImpl::WindowDestroyed() {
diff --git a/libcef/browser/chrome/chrome_browser_main_extra_parts_cef.cc b/libcef/browser/chrome/chrome_browser_main_extra_parts_cef.cc
index e37fd7861..a069d7aa4 100644
--- a/libcef/browser/chrome/chrome_browser_main_extra_parts_cef.cc
+++ b/libcef/browser/chrome/chrome_browser_main_extra_parts_cef.cc
@@ -18,8 +18,9 @@ ChromeBrowserMainExtraPartsCef::~ChromeBrowserMainExtraPartsCef() = default;
 
 void ChromeBrowserMainExtraPartsCef::PostProfileInit(Profile* profile,
                                                      bool is_initial_profile) {
-  if (!is_initial_profile)
+  if (!is_initial_profile) {
     return;
+  }
 
   CefRequestContextSettings settings;
   CefContext::Get()->PopulateGlobalRequestContextSettings(&settings);
diff --git a/libcef/browser/chrome/chrome_content_browser_client_cef.cc b/libcef/browser/chrome/chrome_content_browser_client_cef.cc
index 682e45f8e..6ba3c3d11 100644
--- a/libcef/browser/chrome/chrome_content_browser_client_cef.cc
+++ b/libcef/browser/chrome/chrome_content_browser_client_cef.cc
@@ -58,8 +58,9 @@ void HandleExternalProtocolHelper(
   // May return nullptr if frame has been deleted or a cross-document navigation
   // has committed in the same RenderFrameHost.
   auto initiator_rfh = initiator_document.AsRenderFrameHostIfValid();
-  if (!initiator_rfh)
+  if (!initiator_rfh) {
     return;
+  }
 
   // Match the logic of the original call in
   // NavigationURLLoaderImpl::PrepareForNonInterceptedRequest.
@@ -253,8 +254,9 @@ bool ChromeContentBrowserClientCef::WillCreateURLLoaderFactory(
   // For example, the User Manager profile created via
   // profiles::CreateSystemProfileForUserManager.
   auto profile = Profile::FromBrowserContext(browser_context);
-  if (!CefBrowserContext::FromProfile(profile))
+  if (!CefBrowserContext::FromProfile(profile)) {
     return false;
+  }
 
   auto request_handler = net_service::CreateInterceptedRequestHandler(
       browser_context, frame, render_process_id,
diff --git a/libcef/browser/chrome/chrome_context_menu_handler.cc b/libcef/browser/chrome/chrome_context_menu_handler.cc
index 9b2f794a4..95fa54033 100644
--- a/libcef/browser/chrome/chrome_context_menu_handler.cc
+++ b/libcef/browser/chrome/chrome_context_menu_handler.cc
@@ -40,8 +40,9 @@ class CefContextMenuObserver : public RenderViewContextMenuObserver,
 
   bool IsCommandIdSupported(int command_id) override {
     // Always claim support for the reserved user ID range.
-    if (command_id >= MENU_ID_USER_FIRST && command_id <= MENU_ID_USER_LAST)
+    if (command_id >= MENU_ID_USER_FIRST && command_id <= MENU_ID_USER_LAST) {
       return true;
+    }
 
     // Also claim support in specific cases where an ItemInfo exists.
     return GetItemInfo(command_id) != nullptr;
@@ -104,25 +105,29 @@ class CefContextMenuObserver : public RenderViewContextMenuObserver,
 
   void SetChecked(int command_id, bool checked) override {
     // No-op if already at the default state.
-    if (!checked && !GetItemInfo(command_id))
+    if (!checked && !GetItemInfo(command_id)) {
       return;
+    }
 
     auto* info = GetOrCreateItemInfo(command_id);
     info->checked = checked;
-    if (!checked)
+    if (!checked) {
       MaybeDeleteItemInfo(command_id, info);
+    }
   }
 
   void SetAccelerator(int command_id,
                       absl::optional<ui::Accelerator> accel) override {
     // No-op if already at the default state.
-    if (!accel && !GetItemInfo(command_id))
+    if (!accel && !GetItemInfo(command_id)) {
       return;
+    }
 
     auto* info = GetOrCreateItemInfo(command_id);
     info->accel = accel;
-    if (!accel)
+    if (!accel) {
       MaybeDeleteItemInfo(command_id, info);
+    }
   }
 
  private:
@@ -142,8 +147,9 @@ class CefContextMenuObserver : public RenderViewContextMenuObserver,
   }
 
   ItemInfo* GetOrCreateItemInfo(int command_id) {
-    if (auto info = GetItemInfo(command_id))
+    if (auto info = GetItemInfo(command_id)) {
       return info;
+    }
 
     auto result = iteminfomap_.insert(std::make_pair(command_id, ItemInfo()));
     return &result.first->second;
diff --git a/libcef/browser/chrome/views/browser_platform_delegate_chrome_views.cc b/libcef/browser/chrome/views/browser_platform_delegate_chrome_views.cc
index 153cee055..f54e6bb85 100644
--- a/libcef/browser/chrome/views/browser_platform_delegate_chrome_views.cc
+++ b/libcef/browser/chrome/views/browser_platform_delegate_chrome_views.cc
@@ -32,8 +32,9 @@ class PopupWindowDelegate : public CefWindowDelegate {
 
   bool CanClose(CefRefPtr<CefWindow> window) override {
     CefRefPtr<CefBrowser> browser = browser_view_->GetBrowser();
-    if (browser)
+    if (browser) {
       return browser->GetHost()->TryCloseBrowser();
+    }
     return true;
   }
 
@@ -49,8 +50,9 @@ CefBrowserPlatformDelegateChromeViews::CefBrowserPlatformDelegateChromeViews(
     std::unique_ptr<CefBrowserPlatformDelegateNative> native_delegate,
     CefRefPtr<CefBrowserViewImpl> browser_view)
     : CefBrowserPlatformDelegateChrome(std::move(native_delegate)) {
-  if (browser_view)
+  if (browser_view) {
     SetBrowserView(browser_view);
+  }
 }
 
 void CefBrowserPlatformDelegateChromeViews::SetBrowserView(
@@ -74,13 +76,15 @@ void CefBrowserPlatformDelegateChromeViews::BrowserCreated(
 }
 
 void CefBrowserPlatformDelegateChromeViews::NotifyBrowserCreated() {
-  if (browser_view_->delegate())
+  if (browser_view_->delegate()) {
     browser_view_->delegate()->OnBrowserCreated(browser_view_, browser_);
+  }
 }
 
 void CefBrowserPlatformDelegateChromeViews::NotifyBrowserDestroyed() {
-  if (browser_view_->delegate())
+  if (browser_view_->delegate()) {
     browser_view_->delegate()->OnBrowserDestroyed(browser_view_, browser_);
+  }
 }
 
 void CefBrowserPlatformDelegateChromeViews::BrowserDestroyed(
@@ -91,8 +95,9 @@ void CefBrowserPlatformDelegateChromeViews::BrowserDestroyed(
 
 void CefBrowserPlatformDelegateChromeViews::CloseHostWindow() {
   views::Widget* widget = GetWindowWidget();
-  if (widget && !widget->IsClosed())
+  if (widget && !widget->IsClosed()) {
     widget->Close();
+  }
 }
 
 CefWindowHandle CefBrowserPlatformDelegateChromeViews::GetHostWindowHandle()
@@ -101,8 +106,9 @@ CefWindowHandle CefBrowserPlatformDelegateChromeViews::GetHostWindowHandle()
 }
 
 views::Widget* CefBrowserPlatformDelegateChromeViews::GetWindowWidget() const {
-  if (browser_view_->root_view())
+  if (browser_view_->root_view()) {
     return browser_view_->root_view()->GetWidget();
+  }
   return nullptr;
 }
 
diff --git a/libcef/browser/chrome/views/chrome_browser_view.cc b/libcef/browser/chrome/views/chrome_browser_view.cc
index d85ebdbb6..b7c94a648 100644
--- a/libcef/browser/chrome/views/chrome_browser_view.cc
+++ b/libcef/browser/chrome/views/chrome_browser_view.cc
@@ -53,8 +53,9 @@ void ChromeBrowserView::ViewHierarchyChanged(
       // this View to a CefWindow with FillLayout and then calling
       // CefWindow::Show() without first resizing the CefWindow.
       size = details.parent->GetPreferredSize();
-      if (!size.IsEmpty())
+      if (!size.IsEmpty()) {
         SetSize(size);
+      }
     }
   }
 }
diff --git a/libcef/browser/chrome/views/chrome_child_window.cc b/libcef/browser/chrome/views/chrome_child_window.cc
index d072eaacf..9d1368ac6 100644
--- a/libcef/browser/chrome/views/chrome_child_window.cc
+++ b/libcef/browser/chrome/views/chrome_child_window.cc
@@ -47,8 +47,9 @@ class ChildWindowDelegate : public CefWindowDelegate {
 
   CefRect GetInitialBounds(CefRefPtr<CefWindow> window) override {
     CefRect initial_bounds(window_info_.bounds);
-    if (initial_bounds.IsEmpty())
+    if (initial_bounds.IsEmpty()) {
       return CefRect(0, 0, 800, 600);
+    }
     return initial_bounds;
   }
 
@@ -174,15 +175,18 @@ CefRefPtr<CefBrowserHostBase> MaybeCreateChildBrowser(
     const CefBrowserCreateParams& create_params) {
   // If the BrowserView already exists it means that we're dealing with a popup
   // and we'll instead create the Window in OnPopupBrowserViewCreated.
-  if (create_params.browser_view)
+  if (create_params.browser_view) {
     return nullptr;
+  }
 
-  if (!create_params.window_info)
+  if (!create_params.window_info) {
     return nullptr;
+  }
 
   const auto parent_handle = GetParentHandle(*create_params.window_info);
-  if (parent_handle == gfx::kNullAcceleratedWidget)
+  if (parent_handle == gfx::kNullAcceleratedWidget) {
     return nullptr;
+  }
 
   // Create the BrowserView.
   auto browser_view = CefBrowserViewImpl::Create(
diff --git a/libcef/browser/context.cc b/libcef/browser/context.cc
index dd7d0af3c..9c51a4c3e 100644
--- a/libcef/browser/context.cc
+++ b/libcef/browser/context.cc
@@ -47,8 +47,9 @@ class CefShutdownChecker {
 // loading chrome://system.
 void InitInstallDetails() {
   static bool initialized = false;
-  if (initialized)
+  if (initialized) {
     return;
+  }
   initialized = true;
   install_static::InitializeFromPrimaryModule();
 }
@@ -57,8 +58,9 @@ void InitInstallDetails() {
 // DllMain. See https://crbug.com/656800 for details.
 void InitCrashReporter() {
   static bool initialized = false;
-  if (initialized)
+  if (initialized) {
     return;
+  }
   initialized = true;
   SignalInitializeCrashReporting();
 }
@@ -67,8 +69,9 @@ void InitCrashReporter() {
 
 bool GetColor(const cef_color_t cef_in, bool is_windowless, SkColor* sk_out) {
   // Windowed browser colors must be fully opaque.
-  if (!is_windowless && CefColorGetA(cef_in) != SK_AlphaOPAQUE)
+  if (!is_windowless && CefColorGetA(cef_in) != SK_AlphaOPAQUE) {
     return false;
+  }
 
   // Windowless browser colors may be fully transparent.
   if (is_windowless && CefColorGetA(cef_in) == SK_AlphaTRANSPARENT) {
@@ -86,8 +89,9 @@ bool GetColor(const cef_color_t cef_in, bool is_windowless, SkColor* sk_out) {
 base::FilePath NormalizePath(const cef_string_t& path_str,
                              const char* name,
                              bool* has_error = nullptr) {
-  if (has_error)
+  if (has_error) {
     *has_error = false;
+  }
 
   base::FilePath path = base::FilePath(CefString(&path_str));
   if (path.EndsWithSeparator()) {
@@ -99,8 +103,9 @@ base::FilePath NormalizePath(const cef_string_t& path_str,
   if (!path.empty() && !path.IsAbsolute()) {
     LOG(ERROR) << "The " << name << " directory (" << path.value()
                << ") is not an absolute path. Defaulting to empty.";
-    if (has_error)
+    if (has_error) {
       *has_error = true;
+    }
     path = base::FilePath();
   }
 
@@ -125,8 +130,9 @@ base::FilePath NormalizePathAndSet(cef_string_t& path_str, const char* name) {
 // Verify that |cache_path| is valid and create it if necessary.
 bool ValidateCachePath(const base::FilePath& cache_path,
                        const base::FilePath& root_cache_path) {
-  if (cache_path.empty())
+  if (cache_path.empty()) {
     return true;
+  }
 
   if (!root_cache_path.empty() && root_cache_path != cache_path &&
       !root_cache_path.IsParent(cache_path)) {
@@ -289,8 +295,9 @@ bool CefInitialize(const CefMainArgs& args,
 #endif
 
   // Return true if the global context already exists.
-  if (g_context)
+  if (g_context) {
     return true;
+  }
 
   if (settings.size != sizeof(cef_settings_t)) {
     NOTREACHED() << "invalid CefSettings structure size";
@@ -525,10 +532,12 @@ SkColor CefContext::GetBackgroundColor(
 
 CefTraceSubscriber* CefContext::GetTraceSubscriber() {
   CEF_REQUIRE_UIT();
-  if (shutting_down_)
+  if (shutting_down_) {
     return nullptr;
-  if (!trace_subscriber_.get())
+  }
+  if (!trace_subscriber_.get()) {
     trace_subscriber_.reset(new CefTraceSubscriber());
+  }
   return trace_subscriber_.get();
 }
 
@@ -587,8 +596,9 @@ void CefContext::OnContextInitialized() {
         [](CefRefPtr<CefApp> app) {
           CefRefPtr<CefBrowserProcessHandler> handler =
               app->GetBrowserProcessHandler();
-          if (handler)
+          if (handler) {
             handler->OnContextInitialized();
+          }
         },
         application_));
   }
@@ -599,11 +609,13 @@ void CefContext::ShutdownOnUIThread() {
 
   browser_info_manager_->DestroyAllBrowsers();
 
-  for (auto& observer : observers_)
+  for (auto& observer : observers_) {
     observer.OnContextDestroyed();
+  }
 
-  if (trace_subscriber_.get())
+  if (trace_subscriber_.get()) {
     trace_subscriber_.reset(nullptr);
+  }
 }
 
 void CefContext::FinalizeShutdown() {
diff --git a/libcef/browser/context_menu_params_impl.cc b/libcef/browser/context_menu_params_impl.cc
index c8d817852..fe3be41d1 100644
--- a/libcef/browser/context_menu_params_impl.cc
+++ b/libcef/browser/context_menu_params_impl.cc
@@ -33,18 +33,24 @@ CefContextMenuParamsImpl::TypeFlags CefContextMenuParamsImpl::GetTypeFlags() {
   CEF_VALUE_VERIFY_RETURN(false, CM_TYPEFLAG_NONE);
   const content::ContextMenuParams& params = const_value();
   int type_flags = CM_TYPEFLAG_NONE;
-  if (!params.page_url.is_empty())
+  if (!params.page_url.is_empty()) {
     type_flags |= CM_TYPEFLAG_PAGE;
-  if (!params.frame_url.is_empty())
+  }
+  if (!params.frame_url.is_empty()) {
     type_flags |= CM_TYPEFLAG_FRAME;
-  if (!params.link_url.is_empty())
+  }
+  if (!params.link_url.is_empty()) {
     type_flags |= CM_TYPEFLAG_LINK;
-  if (params.media_type != blink::mojom::ContextMenuDataMediaType::kNone)
+  }
+  if (params.media_type != blink::mojom::ContextMenuDataMediaType::kNone) {
     type_flags |= CM_TYPEFLAG_MEDIA;
-  if (!params.selection_text.empty())
+  }
+  if (!params.selection_text.empty()) {
     type_flags |= CM_TYPEFLAG_SELECTION;
-  if (params.is_editable)
+  }
+  if (params.is_editable) {
     type_flags |= CM_TYPEFLAG_EDITABLE;
+  }
   return static_cast<TypeFlags>(type_flags);
 }
 
@@ -113,16 +119,19 @@ bool CefContextMenuParamsImpl::GetDictionarySuggestions(
     std::vector<CefString>& suggestions) {
   CEF_VALUE_VERIFY_RETURN(false, false);
 
-  if (!suggestions.empty())
+  if (!suggestions.empty()) {
     suggestions.clear();
+  }
 
-  if (const_value().dictionary_suggestions.empty())
+  if (const_value().dictionary_suggestions.empty()) {
     return false;
+  }
 
   std::vector<std::u16string>::const_iterator it =
       const_value().dictionary_suggestions.begin();
-  for (; it != const_value().dictionary_suggestions.end(); ++it)
+  for (; it != const_value().dictionary_suggestions.end(); ++it) {
     suggestions.push_back(*it);
+  }
 
   return true;
 }
diff --git a/libcef/browser/devtools/devtools_controller.cc b/libcef/browser/devtools/devtools_controller.cc
index abb930111..44cd1834e 100644
--- a/libcef/browser/devtools/devtools_controller.cc
+++ b/libcef/browser/devtools/devtools_controller.cc
@@ -31,8 +31,9 @@ CefDevToolsController::~CefDevToolsController() {
 bool CefDevToolsController::SendDevToolsMessage(
     const base::StringPiece& message) {
   CEF_REQUIRE_UIT();
-  if (!EnsureAgentHost())
+  if (!EnsureAgentHost()) {
     return false;
+  }
 
   agent_host_->DispatchProtocolMessage(
       this, base::as_bytes(base::make_span(message)));
@@ -44,25 +45,29 @@ int CefDevToolsController::ExecuteDevToolsMethod(
     const std::string& method,
     const base::DictionaryValue* params) {
   CEF_REQUIRE_UIT();
-  if (!EnsureAgentHost())
+  if (!EnsureAgentHost()) {
     return 0;
+  }
 
   // Message IDs must always be increasing and unique.
   int message_id = suggested_message_id;
-  if (message_id < next_message_id_)
+  if (message_id < next_message_id_) {
     message_id = next_message_id_++;
-  else
+  } else {
     next_message_id_ = message_id + 1;
+  }
 
   base::DictionaryValue message;
   message.SetIntKey("id", message_id);
   message.SetStringKey("method", method);
-  if (params)
+  if (params) {
     message.SetKey("params", params->Clone());
+  }
 
   std::string protocol_message;
-  if (!base::JSONWriter::Write(message, &protocol_message))
+  if (!base::JSONWriter::Write(message, &protocol_message)) {
     return 0;
+  }
 
   agent_host_->DispatchProtocolMessage(
       this, base::as_bytes(base::make_span(protocol_message)));
@@ -91,8 +96,9 @@ void CefDevToolsController::RemoveObserver(Observer* observer) {
 void CefDevToolsController::DispatchProtocolMessage(
     content::DevToolsAgentHost* agent_host,
     base::span<const uint8_t> message) {
-  if (observers_.empty())
+  if (observers_.empty()) {
     return;
+  }
 
   base::StringPiece str_message(reinterpret_cast<const char*>(message.data()),
                                 message.size());
diff --git a/libcef/browser/devtools/devtools_file_manager.cc b/libcef/browser/devtools/devtools_file_manager.cc
index 76a877fa0..ac5912a40 100644
--- a/libcef/browser/devtools/devtools_file_manager.cc
+++ b/libcef/browser/devtools/devtools_file_manager.cc
@@ -82,8 +82,9 @@ void CefDevToolsFileManager::Save(const std::string& url,
 
   if (const base::Value* path_value = file_map.Find(base::MD5String(url))) {
     absl::optional<base::FilePath> path = base::ValueToFilePath(*path_value);
-    if (path)
+    if (path) {
       initial_path = std::move(*path);
+    }
   }
 
   if (initial_path.empty()) {
@@ -91,8 +92,9 @@ void CefDevToolsFileManager::Save(const std::string& url,
     std::string suggested_file_name =
         gurl.is_valid() ? gurl.ExtractFileName() : url;
 
-    if (suggested_file_name.length() > 64)
+    if (suggested_file_name.length() > 64) {
       suggested_file_name = suggested_file_name.substr(0, 64);
+    }
 
     if (!g_last_save_path.Pointer()->empty()) {
       initial_path = g_last_save_path.Pointer()->DirName().AppendASCII(
@@ -167,8 +169,9 @@ void CefDevToolsFileManager::Append(const std::string& url,
                                     const std::string& content,
                                     AppendCallback callback) {
   auto it = saved_files_.find(url);
-  if (it == saved_files_.end())
+  if (it == saved_files_.end()) {
     return;
+  }
   std::move(callback).Run();
   file_task_runner_->PostTask(
       FROM_HERE, base::BindOnce(&::AppendToFile, it->second, content));
diff --git a/libcef/browser/devtools/devtools_frontend.cc b/libcef/browser/devtools/devtools_frontend.cc
index 1982ac366..3ea60c5f1 100644
--- a/libcef/browser/devtools/devtools_frontend.cc
+++ b/libcef/browser/devtools/devtools_frontend.cc
@@ -98,8 +98,9 @@ base::DictionaryValue BuildObjectForResponse(const net::HttpResponseHeaders* rh,
   std::string value;
   // TODO(caseq): this probably needs to handle duplicate header names
   // correctly by folding them.
-  while (rh && rh->EnumerateHeaderLines(&iterator, &name, &value))
+  while (rh && rh->EnumerateHeaderLines(&iterator, &name, &value)) {
     headers->SetString(name, value);
+  }
 
   response.Set("headers", std::move(headers));
   return response;
@@ -135,8 +136,9 @@ void LogProtocolMessage(const base::FilePath& log_file,
                         std::string to_log) {
   // Track if logging has failed, in which case we don't keep trying.
   static bool log_error = false;
-  if (log_error)
+  if (log_error) {
     return;
+  }
 
   if (storage::NativeFileUtil::EnsureFileExists(log_file, nullptr) !=
       base::File::FILE_OK) {
@@ -289,10 +291,12 @@ void CefDevToolsFrontend::Focus() {
 }
 
 void CefDevToolsFrontend::InspectElementAt(int x, int y) {
-  if (inspect_element_at_.x != x || inspect_element_at_.y != y)
+  if (inspect_element_at_.x != x || inspect_element_at_.y != y) {
     inspect_element_at_.Set(x, y);
-  if (agent_host_)
+  }
+  if (agent_host_) {
     agent_host_->InspectElement(inspected_contents_->GetFocusedFrame(), x, y);
+  }
 }
 
 void CefDevToolsFrontend::Close() {
@@ -334,8 +338,9 @@ void CefDevToolsFrontend::ReadyToCommitNavigation(
   std::string origin =
       navigation_handle->GetURL().DeprecatedGetOriginAsURL().spec();
   auto it = extensions_api_.find(origin);
-  if (it == extensions_api_.end())
+  if (it == extensions_api_.end()) {
     return;
+  }
   std::string script = base::StringPrintf("%s(\"%s\")", it->second.c_str(),
                                           base::GenerateGUID().c_str());
   content::DevToolsFrontendHost::SetupExtensionsAPI(frame, script);
@@ -348,8 +353,9 @@ void CefDevToolsFrontend::PrimaryMainDocumentElementAvailable() {
   scoped_refptr<content::DevToolsAgentHost> agent_host =
       content::DevToolsAgentHost::GetOrCreateFor(inspected_contents_);
   if (agent_host != agent_host_) {
-    if (agent_host_)
+    if (agent_host_) {
       agent_host_->DetachClient(this);
+    }
     agent_host_ = agent_host;
     agent_host_->AttachClient(this);
     if (!inspect_element_at_.IsEmpty()) {
@@ -371,8 +377,9 @@ void CefDevToolsFrontend::WebContentsDestroyed() {
 void CefDevToolsFrontend::HandleMessageFromDevToolsFrontend(
     base::Value::Dict message) {
   const std::string* method = message.FindString("method");
-  if (!method)
+  if (!method) {
     return;
+  }
 
   int request_id = message.FindInt("id").value_or(0);
   base::Value::List* params_value = message.FindList("params");
@@ -384,11 +391,13 @@ void CefDevToolsFrontend::HandleMessageFromDevToolsFrontend(
   }
 
   if (*method == "dispatchProtocolMessage") {
-    if (params.size() < 1)
+    if (params.size() < 1) {
       return;
+    }
     const std::string* protocol_message = params[0].GetIfString();
-    if (!agent_host_ || !protocol_message)
+    if (!agent_host_ || !protocol_message) {
       return;
+    }
     if (ProtocolLoggingEnabled()) {
       LogProtocolMessage(ProtocolMessageType::METHOD, *protocol_message);
     }
@@ -398,8 +407,9 @@ void CefDevToolsFrontend::HandleMessageFromDevToolsFrontend(
     web_contents()->GetPrimaryMainFrame()->ExecuteJavaScriptForTests(
         u"DevToolsAPI.setUseSoftMenu(true);", base::NullCallback());
   } else if (*method == "loadNetworkResource") {
-    if (params.size() < 3)
+    if (params.size() < 3) {
       return;
+    }
 
     // TODO(pfeldman): handle some of the embedder messages in content.
     const std::string* url = params[0].GetIfString();
@@ -486,62 +496,73 @@ void CefDevToolsFrontend::HandleMessageFromDevToolsFrontend(
         base::Value(GetPrefs()->GetDict(prefs::kDevToolsPreferences).Clone()));
     return;
   } else if (*method == "setPreference") {
-    if (params.size() < 2)
+    if (params.size() < 2) {
       return;
+    }
     const std::string* name = params[0].GetIfString();
 
     // We're just setting params[1] as a value anyways, so just make sure it's
     // the type we want, but don't worry about getting it.
-    if (!name || !params[1].is_string())
+    if (!name || !params[1].is_string()) {
       return;
+    }
 
     DictionaryPrefUpdate update(GetPrefs(), prefs::kDevToolsPreferences);
     update.Get()->SetKey(*name, std::move(params[1]));
   } else if (*method == "removePreference") {
     const std::string* name = params[0].GetIfString();
-    if (!name)
+    if (!name) {
       return;
+    }
     DictionaryPrefUpdate update(GetPrefs(), prefs::kDevToolsPreferences);
     update.Get()->RemoveKey(*name);
   } else if (*method == "requestFileSystems") {
     web_contents()->GetPrimaryMainFrame()->ExecuteJavaScriptForTests(
         u"DevToolsAPI.fileSystemsLoaded([]);", base::NullCallback());
   } else if (*method == "reattach") {
-    if (!agent_host_)
+    if (!agent_host_) {
       return;
+    }
     agent_host_->DetachClient(this);
     agent_host_->AttachClient(this);
   } else if (*method == "registerExtensionsAPI") {
-    if (params.size() < 2)
+    if (params.size() < 2) {
       return;
+    }
     const std::string* origin = params[0].GetIfString();
     const std::string* script = params[1].GetIfString();
-    if (!origin || !script)
+    if (!origin || !script) {
       return;
+    }
     extensions_api_[*origin + "/"] = *script;
   } else if (*method == "save") {
-    if (params.size() < 3)
+    if (params.size() < 3) {
       return;
+    }
     const std::string* url = params[0].GetIfString();
     const std::string* content = params[1].GetIfString();
     absl::optional<bool> save_as = params[2].GetIfBool();
-    if (!url || !content || !save_as.has_value())
+    if (!url || !content || !save_as.has_value()) {
       return;
+    }
     file_manager_.SaveToFile(*url, *content, *save_as);
   } else if (*method == "append") {
-    if (params.size() < 2)
+    if (params.size() < 2) {
       return;
+    }
     const std::string* url = params[0].GetIfString();
     const std::string* content = params[1].GetIfString();
-    if (!url || !content)
+    if (!url || !content) {
       return;
+    }
     file_manager_.AppendToFile(*url, *content);
   } else {
     return;
   }
 
-  if (request_id)
+  if (request_id) {
     SendMessageAck(request_id, base::Value());
+  }
 }
 
 void CefDevToolsFrontend::DispatchProtocolMessage(
diff --git a/libcef/browser/devtools/devtools_manager.cc b/libcef/browser/devtools/devtools_manager.cc
index efbab31ed..900e4b8fa 100644
--- a/libcef/browser/devtools/devtools_manager.cc
+++ b/libcef/browser/devtools/devtools_manager.cc
@@ -30,8 +30,9 @@ class CefDevToolsRegistrationImpl : public CefRegistration,
     CEF_REQUIRE_UIT();
 
     // May be null if OnDevToolsControllerDestroyed was called.
-    if (!controller_)
+    if (!controller_) {
       return;
+    }
 
     controller_->RemoveObserver(this);
   }
@@ -132,8 +133,9 @@ void CefDevToolsManager::ShowDevTools(const CefWindowInfo& windowInfo,
 
 void CefDevToolsManager::CloseDevTools() {
   CEF_REQUIRE_UIT();
-  if (!devtools_frontend_)
+  if (!devtools_frontend_) {
     return;
+  }
   devtools_frontend_->Close();
 }
 
@@ -145,11 +147,13 @@ bool CefDevToolsManager::HasDevTools() {
 bool CefDevToolsManager::SendDevToolsMessage(const void* message,
                                              size_t message_size) {
   CEF_REQUIRE_UIT();
-  if (!message || message_size == 0)
+  if (!message || message_size == 0) {
     return false;
+  }
 
-  if (!EnsureController())
+  if (!EnsureController()) {
     return false;
+  }
 
   return devtools_controller_->SendDevToolsMessage(
       base::StringPiece(static_cast<const char*>(message), message_size));
@@ -160,11 +164,13 @@ int CefDevToolsManager::ExecuteDevToolsMethod(
     const CefString& method,
     CefRefPtr<CefDictionaryValue> params) {
   CEF_REQUIRE_UIT();
-  if (method.empty())
+  if (method.empty()) {
     return 0;
+  }
 
-  if (!EnsureController())
+  if (!EnsureController()) {
     return 0;
+  }
 
   if (params && params->IsValid()) {
     CefDictionaryValueImpl* impl =
@@ -189,8 +195,9 @@ void CefDevToolsManager::InitializeRegistrationOnUIThread(
     CefRefPtr<CefRegistration> registration) {
   CEF_REQUIRE_UIT();
 
-  if (!EnsureController())
+  if (!EnsureController()) {
     return;
+  }
 
   static_cast<CefDevToolsRegistrationImpl*>(registration.get())
       ->Initialize(inspected_browser_, devtools_controller_->GetWeakPtr());
diff --git a/libcef/browser/devtools/devtools_manager_delegate.cc b/libcef/browser/devtools/devtools_manager_delegate.cc
index e36a3e80c..55fe2e74f 100644
--- a/libcef/browser/devtools/devtools_manager_delegate.cc
+++ b/libcef/browser/devtools/devtools_manager_delegate.cc
@@ -51,8 +51,10 @@ class TCPServerSocketFactory : public content::DevToolsSocketFactory {
   std::unique_ptr<net::ServerSocket> CreateForHttpServer() override {
     std::unique_ptr<net::ServerSocket> socket(
         new net::TCPServerSocket(nullptr, net::NetLogSource()));
-    if (socket->ListenWithAddressAndPort(address_, port_, kBackLog) != net::OK)
+    if (socket->ListenWithAddressAndPort(address_, port_, kBackLog) !=
+        net::OK) {
       return std::unique_ptr<net::ServerSocket>();
+    }
     return socket;
   }
 
@@ -85,8 +87,9 @@ std::unique_ptr<content::DevToolsSocketFactory> CreateSocketFactory() {
       DLOG(WARNING) << "Invalid http debugger port number " << temp_port;
     }
   }
-  if (port == 0)
+  if (port == 0) {
     return nullptr;
+  }
   return std::unique_ptr<content::DevToolsSocketFactory>(
       new TCPServerSocketFactory("127.0.0.1", port));
 }
@@ -100,8 +103,9 @@ void CefDevToolsManagerDelegate::StartHttpHandler(
     content::BrowserContext* browser_context) {
   std::unique_ptr<content::DevToolsSocketFactory> socket_factory =
       CreateSocketFactory();
-  if (!socket_factory)
+  if (!socket_factory) {
     return;
+  }
   content::DevToolsAgentHost::StartRemoteDebuggingServer(
       std::move(socket_factory), browser_context->GetPath(), base::FilePath());
 
diff --git a/libcef/browser/devtools/devtools_util.cc b/libcef/browser/devtools/devtools_util.cc
index d0d7799a5..1ba53b124 100644
--- a/libcef/browser/devtools/devtools_util.cc
+++ b/libcef/browser/devtools/devtools_util.cc
@@ -25,16 +25,19 @@ bool ParseEvent(const base::StringPiece& message,
   static const char kMethodEnd[] = "\"";
   static const char kParamsStart[] = ",\"params\":";
 
-  if (!base::StartsWith(message, kMethodStart))
+  if (!base::StartsWith(message, kMethodStart)) {
     return false;
+  }
 
   const size_t method_start = sizeof(kMethodStart) - 1;
   const size_t method_end = message.find(kMethodEnd, method_start);
-  if (method_end == base::StringPiece::npos)
+  if (method_end == base::StringPiece::npos) {
     return false;
+  }
   method = message.substr(method_start, method_end - method_start);
-  if (method.empty())
+  if (method.empty()) {
     return false;
+  }
 
   size_t remainder_start = method_end + sizeof(kMethodEnd) - 1;
   if (remainder_start == message.size() - 1) {
@@ -52,8 +55,9 @@ bool ParseEvent(const base::StringPiece& message,
       return false;
     }
 
-    if (!IsValidDictionary(params, /*allow_empty=*/true))
+    if (!IsValidDictionary(params, /*allow_empty=*/true)) {
       return false;
+    }
   }
 
   return true;
@@ -72,16 +76,19 @@ bool ParseResult(const base::StringPiece& message,
   static const char kResultStart[] = "\"result\":";
   static const char kErrorStart[] = "\"error\":";
 
-  if (!base::StartsWith(message, kIdStart))
+  if (!base::StartsWith(message, kIdStart)) {
     return false;
+  }
 
   const size_t id_start = sizeof(kIdStart) - 1;
   const size_t id_end = message.find(kIdEnd, id_start);
-  if (id_end == base::StringPiece::npos)
+  if (id_end == base::StringPiece::npos) {
     return false;
+  }
   const base::StringPiece& id_str = message.substr(id_start, id_end - id_start);
-  if (id_str.empty() || !base::StringToInt(id_str, &message_id))
+  if (id_str.empty() || !base::StringToInt(id_str, &message_id)) {
     return false;
+  }
 
   size_t remainder_start = id_end + sizeof(kIdEnd) - 1;
   const base::StringPiece& remainder = message.substr(remainder_start);
@@ -102,8 +109,9 @@ bool ParseResult(const base::StringPiece& message,
     return false;
   }
 
-  if (!IsValidDictionary(result, /*allow_empty=*/true))
+  if (!IsValidDictionary(result, /*allow_empty=*/true)) {
     return false;
+  }
 
   return true;
 }
@@ -116,8 +124,9 @@ bool ProtocolParser::IsValidMessage(const base::StringPiece& message) {
 }
 
 bool ProtocolParser::Initialize(const base::StringPiece& message) {
-  if (status_ != UNINITIALIZED)
+  if (status_ != UNINITIALIZED) {
     return false;
+  }
 
   if (ParseEvent(message, method_, params_)) {
     status_ = EVENT;
diff --git a/libcef/browser/download_manager_delegate.cc b/libcef/browser/download_manager_delegate.cc
index 54be41674..2f893e8d8 100644
--- a/libcef/browser/download_manager_delegate.cc
+++ b/libcef/browser/download_manager_delegate.cc
@@ -35,8 +35,9 @@ namespace {
 CefRefPtr<CefDownloadHandler> GetDownloadHandler(
     CefRefPtr<AlloyBrowserHostImpl> browser) {
   CefRefPtr<CefClient> client = browser->GetClient();
-  if (client.get())
+  if (client.get()) {
     return client->GetDownloadHandler();
+  }
   return nullptr;
 }
 
@@ -58,8 +59,9 @@ class CefBeforeDownloadCallbackImpl : public CefBeforeDownloadCallback {
 
   void Continue(const CefString& download_path, bool show_dialog) override {
     if (CEF_CURRENTLY_ON_UIT()) {
-      if (download_id_ <= 0)
+      if (download_id_ <= 0) {
         return;
+      }
 
       if (manager_) {
         base::FilePath path = base::FilePath(download_path);
@@ -119,12 +121,14 @@ class CefBeforeDownloadCallbackImpl : public CefBeforeDownloadCallback {
                                  const base::FilePath& suggested_path,
                                  bool show_dialog,
                                  content::DownloadTargetCallback callback) {
-    if (!manager)
+    if (!manager) {
       return;
+    }
 
     DownloadItem* item = manager->GetDownload(download_id);
-    if (!item || item->GetState() != DownloadItem::IN_PROGRESS)
+    if (!item || item->GetState() != DownloadItem::IN_PROGRESS) {
       return;
+    }
 
     bool handled = false;
 
@@ -170,8 +174,9 @@ class CefBeforeDownloadCallbackImpl : public CefBeforeDownloadCallback {
     DCHECK_LE(file_paths.size(), (size_t)1);
 
     base::FilePath path;
-    if (file_paths.size() > 0)
+    if (file_paths.size() > 0) {
       path = file_paths.front();
+    }
 
     // The download will be cancelled if |path| is empty.
     std::move(callback).Run(path, DownloadItem::TARGET_DISPOSITION_OVERWRITE,
@@ -218,37 +223,43 @@ class CefDownloadItemCallbackImpl : public CefDownloadItemCallback {
 
  private:
   void DoCancel() {
-    if (download_id_ <= 0)
+    if (download_id_ <= 0) {
       return;
+    }
 
     if (manager_) {
       DownloadItem* item = manager_->GetDownload(download_id_);
-      if (item && item->GetState() == DownloadItem::IN_PROGRESS)
+      if (item && item->GetState() == DownloadItem::IN_PROGRESS) {
         item->Cancel(true);
+      }
     }
 
     download_id_ = 0;
   }
 
   void DoPause() {
-    if (download_id_ <= 0)
+    if (download_id_ <= 0) {
       return;
+    }
 
     if (manager_) {
       DownloadItem* item = manager_->GetDownload(download_id_);
-      if (item && item->GetState() == DownloadItem::IN_PROGRESS)
+      if (item && item->GetState() == DownloadItem::IN_PROGRESS) {
         item->Pause();
+      }
     }
   }
 
   void DoResume() {
-    if (download_id_ <= 0)
+    if (download_id_ <= 0) {
       return;
+    }
 
     if (manager_) {
       DownloadItem* item = manager_->GetDownload(download_id_);
-      if (item && item->CanResume())
+      if (item && item->CanResume()) {
         item->Resume(true);
+      }
     }
   }
 
@@ -268,8 +279,9 @@ CefDownloadManagerDelegate::CefDownloadManagerDelegate(DownloadManager* manager)
   DownloadManager::DownloadVector items;
   manager->GetAllDownloads(&items);
   DownloadManager::DownloadVector::const_iterator it = items.begin();
-  for (; it != items.end(); ++it)
+  for (; it != items.end(); ++it) {
     OnDownloadCreated(manager, *it);
+  }
 }
 
 CefDownloadManagerDelegate::~CefDownloadManagerDelegate() {
@@ -278,15 +290,17 @@ CefDownloadManagerDelegate::~CefDownloadManagerDelegate() {
     manager_->RemoveObserver(this);
   }
 
-  while (!item_browser_map_.empty())
+  while (!item_browser_map_.empty()) {
     OnDownloadDestroyed(item_browser_map_.begin()->first);
+  }
 }
 
 void CefDownloadManagerDelegate::OnDownloadUpdated(DownloadItem* download) {
   CefRefPtr<AlloyBrowserHostImpl> browser = GetBrowser(download);
   CefRefPtr<CefDownloadHandler> handler;
-  if (browser.get())
+  if (browser.get()) {
     handler = GetDownloadHandler(browser);
+  }
 
   if (handler.get()) {
     CefRefPtr<CefDownloadItemImpl> download_item(
@@ -324,8 +338,9 @@ void CefDownloadManagerDelegate::OnDownloadDestroyed(DownloadItem* item) {
       }
     }
 
-    if (!has_remaining)
+    if (!has_remaining) {
       browser->RemoveObserver(this);
+    }
   }
 }
 
@@ -374,8 +389,9 @@ bool CefDownloadManagerDelegate::DetermineDownloadTarget(
   // from either method.
   CefRefPtr<AlloyBrowserHostImpl> browser = GetOrAssociateBrowser(item);
   CefRefPtr<CefDownloadHandler> handler;
-  if (browser.get())
+  if (browser.get()) {
     handler = GetDownloadHandler(browser);
+  }
 
   if (handler.get()) {
     base::FilePath suggested_name = net::GenerateFileName(
@@ -423,8 +439,9 @@ void CefDownloadManagerDelegate::OnBrowserDestroyed(
 AlloyBrowserHostImpl* CefDownloadManagerDelegate::GetOrAssociateBrowser(
     download::DownloadItem* item) {
   ItemBrowserMap::const_iterator it = item_browser_map_.find(item);
-  if (it != item_browser_map_.end())
+  if (it != item_browser_map_.end()) {
     return it->second;
+  }
 
   AlloyBrowserHostImpl* browser = nullptr;
   content::WebContents* contents =
@@ -433,8 +450,9 @@ AlloyBrowserHostImpl* CefDownloadManagerDelegate::GetOrAssociateBrowser(
     browser = AlloyBrowserHostImpl::GetBrowserForContents(contents).get();
     DCHECK(browser);
   }
-  if (!browser)
+  if (!browser) {
     return nullptr;
+  }
 
   item->AddObserver(this);
 
@@ -442,8 +460,9 @@ AlloyBrowserHostImpl* CefDownloadManagerDelegate::GetOrAssociateBrowser(
 
   // Register as an observer so that we can cancel associated DownloadItems when
   // the browser is destroyed.
-  if (!browser->HasObserver(this))
+  if (!browser->HasObserver(this)) {
     browser->AddObserver(this);
+  }
 
   return browser;
 }
@@ -451,8 +470,9 @@ AlloyBrowserHostImpl* CefDownloadManagerDelegate::GetOrAssociateBrowser(
 AlloyBrowserHostImpl* CefDownloadManagerDelegate::GetBrowser(
     DownloadItem* item) {
   ItemBrowserMap::const_iterator it = item_browser_map_.find(item);
-  if (it != item_browser_map_.end())
+  if (it != item_browser_map_.end()) {
     return it->second;
+  }
 
   // If the download is rejected (e.g. ALT+click on an invalid protocol link)
   // then an "interrupted" download will be started via DownloadManagerImpl::
diff --git a/libcef/browser/extension_impl.cc b/libcef/browser/extension_impl.cc
index a3fe50083..61f578738 100644
--- a/libcef/browser/extension_impl.cc
+++ b/libcef/browser/extension_impl.cc
@@ -37,12 +37,14 @@ CefRefPtr<CefDictionaryValue> CefExtensionImpl::GetManifest() {
 
 bool CefExtensionImpl::IsSame(CefRefPtr<CefExtension> that) {
   CefExtensionImpl* that_impl = static_cast<CefExtensionImpl*>(that.get());
-  if (!that_impl)
+  if (!that_impl) {
     return false;
+  }
 
   // Maybe the same object.
-  if (this == that_impl)
+  if (this == that_impl) {
     return true;
+  }
 
   return id_ == that_impl->id_ && path_ == that_impl->path_ &&
          loader_context_ == that_impl->loader_context_;
@@ -77,11 +79,13 @@ void CefExtensionImpl::Unload() {
   }
 
   // Will be NULL for internal extensions. They can't be unloaded.
-  if (!loader_context_)
+  if (!loader_context_) {
     return;
+  }
 
-  if (unloaded_)
+  if (unloaded_) {
     return;
+  }
 
   // CefExtensionHandler callbacks triggered by UnloadExtension may check this
   // flag, so set it here.
@@ -96,8 +100,9 @@ void CefExtensionImpl::Unload() {
 
 void CefExtensionImpl::OnExtensionLoaded() {
   CEF_REQUIRE_UIT();
-  if (handler_)
+  if (handler_) {
     handler_->OnExtensionLoaded(this);
+  }
 }
 
 void CefExtensionImpl::OnExtensionUnloaded() {
@@ -108,6 +113,7 @@ void CefExtensionImpl::OnExtensionUnloaded() {
   unloaded_ = true;
   loader_context_ = nullptr;
 
-  if (handler_)
+  if (handler_) {
     handler_->OnExtensionUnloaded(this);
+  }
 }
diff --git a/libcef/browser/extensions/alloy_extensions_util.cc b/libcef/browser/extensions/alloy_extensions_util.cc
index 0dabb1b22..a802ab1b1 100644
--- a/libcef/browser/extensions/alloy_extensions_util.cc
+++ b/libcef/browser/extensions/alloy_extensions_util.cc
@@ -11,8 +11,9 @@ namespace alloy {
 
 int GetTabIdForWebContents(content::WebContents* web_contents) {
   auto browser = AlloyBrowserHostImpl::GetBrowserForContents(web_contents);
-  if (!browser)
+  if (!browser) {
     return -1;
+  }
   return browser->GetIdentifier();
 }
 
diff --git a/libcef/browser/extensions/api/file_system/cef_file_system_delegate.cc b/libcef/browser/extensions/api/file_system/cef_file_system_delegate.cc
index 5941c7438..687505400 100644
--- a/libcef/browser/extensions/api/file_system/cef_file_system_delegate.cc
+++ b/libcef/browser/extensions/api/file_system/cef_file_system_delegate.cc
@@ -68,12 +68,15 @@ void CefFileSystemDelegate::ConfirmSensitiveDirectoryAccess(
 // Based on ChromeFileSystemDelegate::GetDescriptionIdForAcceptType.
 int CefFileSystemDelegate::GetDescriptionIdForAcceptType(
     const std::string& accept_type) {
-  if (accept_type == "image/*")
+  if (accept_type == "image/*") {
     return IDS_IMAGE_FILES;
-  if (accept_type == "audio/*")
+  }
+  if (accept_type == "audio/*") {
     return IDS_AUDIO_FILES;
-  if (accept_type == "video/*")
+  }
+  if (accept_type == "video/*") {
     return IDS_VIDEO_FILES;
+  }
   return 0;
 }
 
diff --git a/libcef/browser/extensions/api/storage/sync_value_store_cache.cc b/libcef/browser/extensions/api/storage/sync_value_store_cache.cc
index b73879cd5..5dff6f61b 100644
--- a/libcef/browser/extensions/api/storage/sync_value_store_cache.cc
+++ b/libcef/browser/extensions/api/storage/sync_value_store_cache.cc
@@ -82,8 +82,9 @@ void SyncValueStoreCache::DeleteStorageSoon(const std::string& extension_id) {
 value_store::ValueStore* SyncValueStoreCache::GetStorage(
     const Extension* extension) {
   auto iter = storage_map_.find(extension->id());
-  if (iter != storage_map_.end())
+  if (iter != storage_map_.end()) {
     return iter->second.get();
+  }
 
   value_store_util::ModelType model_type =
       extension->is_app() ? value_store_util::ModelType::APP
diff --git a/libcef/browser/extensions/api/tabs/tabs_api.cc b/libcef/browser/extensions/api/tabs/tabs_api.cc
index cae0ea4c4..3fc19ef22 100644
--- a/libcef/browser/extensions/api/tabs/tabs_api.cc
+++ b/libcef/browser/extensions/api/tabs/tabs_api.cc
@@ -85,8 +85,9 @@ ExtensionFunction::ResponseAction TabsCreateFunction::Run() {
 
   std::string error;
   auto result = cef_details_.OpenTab(options, user_gesture(), &error);
-  if (!result)
+  if (!result) {
     return RespondNow(Error(error));
+  }
 
   // Return data about the newly created tab.
   return RespondNow(has_callback() ? OneArgument(base::Value(result->ToValue()))
@@ -99,8 +100,9 @@ content::WebContents* BaseAPIFunction::GetWebContents(int tab_id) {
   // Find a browser that we can access, or set |error_| and return nullptr.
   CefRefPtr<AlloyBrowserHostImpl> browser =
       cef_details_.GetBrowserForTabIdFirstTime(tab_id, &error_);
-  if (!browser)
+  if (!browser) {
     return nullptr;
+  }
 
   return browser->web_contents();
 }
@@ -112,8 +114,9 @@ ExtensionFunction::ResponseAction TabsUpdateFunction::Run() {
 
   tab_id_ = params->tab_id ? *params->tab_id : -1;
   content::WebContents* web_contents = GetWebContents(tab_id_);
-  if (!web_contents)
+  if (!web_contents) {
     return RespondNow(Error(std::move(error_)));
+  }
 
   web_contents_ = web_contents;
 
@@ -124,19 +127,22 @@ ExtensionFunction::ResponseAction TabsUpdateFunction::Run() {
   // Navigate the tab to a new location if the url is different.
   if (params->update_properties.url.has_value()) {
     std::string updated_url = *params->update_properties.url;
-    if (!UpdateURL(updated_url, tab_id_, &error_))
+    if (!UpdateURL(updated_url, tab_id_, &error_)) {
       return RespondNow(Error(std::move(error_)));
+    }
   }
 
   bool active = false;
   // TODO(rafaelw): Setting |active| from js doesn't make much sense.
   // Move tab selection management up to window.
-  if (params->update_properties.selected.has_value())
+  if (params->update_properties.selected.has_value()) {
     active = *params->update_properties.selected;
+  }
 
   // The 'active' property has replaced 'selected'.
-  if (params->update_properties.active.has_value())
+  if (params->update_properties.active.has_value()) {
     active = *params->update_properties.active;
+  }
 
   if (active) {
     // TODO: Activate the tab at |tab_id_|.
@@ -168,8 +174,9 @@ ExtensionFunction::ResponseAction TabsUpdateFunction::Run() {
 
   if (params->update_properties.opener_tab_id.has_value()) {
     int opener_id = *params->update_properties.opener_tab_id;
-    if (opener_id == tab_id_)
+    if (opener_id == tab_id_) {
       return RespondNow(Error("Cannot set a tab's opener to itself."));
+    }
 
     // TODO: Set the opener for the tab at |tab_id_|.
     NOTIMPLEMENTED();
@@ -227,8 +234,9 @@ bool TabsUpdateFunction::UpdateURL(const std::string& url_string,
 }
 
 ExtensionFunction::ResponseValue TabsUpdateFunction::GetResult() {
-  if (!has_callback())
+  if (!has_callback()) {
     return NoArguments();
+  }
 
   return ArgumentList(tabs::Get::Results::Create(cef_details_.CreateTabObject(
       AlloyBrowserHostImpl::GetBrowserForContents(web_contents_),
@@ -241,11 +249,13 @@ ExecuteCodeInTabFunction::ExecuteCodeInTabFunction()
 ExecuteCodeInTabFunction::~ExecuteCodeInTabFunction() {}
 
 ExecuteCodeFunction::InitResult ExecuteCodeInTabFunction::Init() {
-  if (init_result_)
+  if (init_result_) {
     return init_result_.value();
+  }
 
-  if (args().size() < 2)
+  if (args().size() < 2) {
     return set_init_result(VALIDATION_FAILURE);
+  }
 
   const auto& tab_id_value = args()[0];
   // |tab_id| is optional so it's ok if it's not there.
@@ -260,18 +270,21 @@ ExecuteCodeFunction::InitResult ExecuteCodeInTabFunction::Init() {
 
   // |details| are not optional.
   const base::Value& details_value = args()[1];
-  if (!details_value.is_dict())
+  if (!details_value.is_dict()) {
     return set_init_result(VALIDATION_FAILURE);
+  }
   std::unique_ptr<InjectDetails> details(new InjectDetails());
-  if (!InjectDetails::Populate(details_value, details.get()))
+  if (!InjectDetails::Populate(details_value, details.get())) {
     return set_init_result(VALIDATION_FAILURE);
+  }
 
   // Find a browser that we can access, or fail with error.
   std::string error;
   CefRefPtr<AlloyBrowserHostImpl> browser =
       cef_details_.GetBrowserForTabIdFirstTime(tab_id, &error);
-  if (!browser)
+  if (!browser) {
     return set_init_result_error(error);
+  }
 
   execute_tab_id_ = browser->GetIdentifier();
   details_ = std::move(details);
@@ -293,8 +306,9 @@ bool ExecuteCodeInTabFunction::CanExecuteScriptOnPage(std::string* error) {
 
   CefRefPtr<AlloyBrowserHostImpl> browser =
       cef_details_.GetBrowserForTabIdAgain(execute_tab_id_, error);
-  if (!browser)
+  if (!browser) {
     return false;
+  }
 
   int frame_id = details_->frame_id ? *details_->frame_id
                                     : ExtensionApiFrameIdMap::kTopFrameId;
@@ -348,8 +362,9 @@ ScriptExecutor* ExecuteCodeInTabFunction::GetScriptExecutor(
 
   CefRefPtr<AlloyBrowserHostImpl> browser =
       cef_details_.GetBrowserForTabIdAgain(execute_tab_id_, error);
-  if (!browser)
+  if (!browser) {
     return nullptr;
+  }
 
   return CefExtensionWebContentsObserver::FromWebContents(
              browser->web_contents())
@@ -406,12 +421,14 @@ ExtensionFunction::ResponseAction TabsSetZoomFunction::Run() {
 
   int tab_id = params->tab_id ? *params->tab_id : -1;
   content::WebContents* web_contents = GetWebContents(tab_id);
-  if (!web_contents)
+  if (!web_contents) {
     return RespondNow(Error(std::move(error_)));
+  }
 
   GURL url(web_contents->GetVisibleURL());
-  if (extension()->permissions_data()->IsRestrictedUrl(url, &error_))
+  if (extension()->permissions_data()->IsRestrictedUrl(url, &error_)) {
     return RespondNow(Error(std::move(error_)));
+  }
 
   ZoomController* zoom_controller =
       ZoomController::FromWebContents(web_contents);
@@ -436,8 +453,9 @@ ExtensionFunction::ResponseAction TabsGetZoomFunction::Run() {
 
   int tab_id = params->tab_id ? *params->tab_id : -1;
   content::WebContents* web_contents = GetWebContents(tab_id);
-  if (!web_contents)
+  if (!web_contents) {
     return RespondNow(Error(std::move(error_)));
+  }
 
   double zoom_level =
       zoom::ZoomController::FromWebContents(web_contents)->GetZoomLevel();
@@ -455,13 +473,15 @@ ExtensionFunction::ResponseAction TabsSetZoomSettingsFunction::Run() {
 
   int tab_id = params->tab_id ? *params->tab_id : -1;
   content::WebContents* web_contents = GetWebContents(tab_id);
-  if (!web_contents)
+  if (!web_contents) {
     return RespondNow(Error(std::move(error_)));
+  }
 
   GURL url(web_contents->GetVisibleURL());
   std::string error;
-  if (extension()->permissions_data()->IsRestrictedUrl(url, &error_))
+  if (extension()->permissions_data()->IsRestrictedUrl(url, &error_)) {
     return RespondNow(Error(std::move(error_)));
+  }
 
   // "per-origin" scope is only available in "automatic" mode.
   if (params->zoom_settings.scope == tabs::ZOOM_SETTINGS_SCOPE_PER_ORIGIN &&
@@ -504,8 +524,9 @@ ExtensionFunction::ResponseAction TabsGetZoomSettingsFunction::Run() {
 
   int tab_id = params->tab_id ? *params->tab_id : -1;
   content::WebContents* web_contents = GetWebContents(tab_id);
-  if (!web_contents)
+  if (!web_contents) {
     return RespondNow(Error(std::move(error_)));
+  }
   ZoomController* zoom_controller =
       ZoomController::FromWebContents(web_contents);
 
diff --git a/libcef/browser/extensions/browser_extensions_util.cc b/libcef/browser/extensions/browser_extensions_util.cc
index 74e94b9e2..9a780e229 100644
--- a/libcef/browser/extensions/browser_extensions_util.cc
+++ b/libcef/browser/extensions/browser_extensions_util.cc
@@ -65,8 +65,9 @@ CefRefPtr<CefBrowserHostBase> GetOwnerBrowserForGlobalId(
     // Use the non-thread-safe but potentially faster approach.
     content::RenderFrameHost* host =
         content::RenderFrameHost::FromID(global_id);
-    if (host)
+    if (host) {
       return GetOwnerBrowserForHost(host, is_guest_view);
+    }
     return nullptr;
   } else {
     // Use the thread-safe approach.
@@ -89,8 +90,9 @@ CefRefPtr<CefBrowserHostBase> GetOwnerBrowserForGlobalId(
 CefRefPtr<CefBrowserHostBase> GetOwnerBrowserForHost(
     content::RenderViewHost* host,
     bool* is_guest_view) {
-  if (is_guest_view)
+  if (is_guest_view) {
     *is_guest_view = false;
+  }
 
   CefRefPtr<CefBrowserHostBase> browser =
       CefBrowserHostBase::GetBrowserForHost(host);
@@ -100,8 +102,9 @@ CefRefPtr<CefBrowserHostBase> GetOwnerBrowserForHost(
         content::WebContents::FromRenderViewHost(host));
     if (owner) {
       browser = CefBrowserHostBase::GetBrowserForContents(owner);
-      if (browser.get() && is_guest_view)
+      if (browser.get() && is_guest_view) {
         *is_guest_view = true;
+      }
     }
   }
   return browser;
@@ -110,8 +113,9 @@ CefRefPtr<CefBrowserHostBase> GetOwnerBrowserForHost(
 CefRefPtr<CefBrowserHostBase> GetOwnerBrowserForHost(
     content::RenderFrameHost* host,
     bool* is_guest_view) {
-  if (is_guest_view)
+  if (is_guest_view) {
     *is_guest_view = false;
+  }
 
   CefRefPtr<CefBrowserHostBase> browser =
       CefBrowserHostBase::GetBrowserForHost(host);
@@ -121,8 +125,9 @@ CefRefPtr<CefBrowserHostBase> GetOwnerBrowserForHost(
         content::WebContents::FromRenderFrameHost(host));
     if (owner) {
       browser = CefBrowserHostBase::GetBrowserForContents(owner);
-      if (browser.get() && is_guest_view)
+      if (browser.get() && is_guest_view) {
         *is_guest_view = true;
+      }
     }
   }
   return browser;
@@ -134,8 +139,9 @@ CefRefPtr<AlloyBrowserHostImpl> GetBrowserForTabId(
   REQUIRE_ALLOY_RUNTIME();
   CEF_REQUIRE_UIT();
   DCHECK(browser_context);
-  if (tab_id < 0 || !browser_context)
+  if (tab_id < 0 || !browser_context) {
     return nullptr;
+  }
 
   auto cef_browser_context =
       CefBrowserContext::FromBrowserContext(browser_context);
@@ -164,8 +170,9 @@ CefRefPtr<AlloyBrowserHostImpl> GetBrowserForTabId(
 const Extension* GetExtensionForUrl(content::BrowserContext* browser_context,
                                     const GURL& url) {
   ExtensionRegistry* registry = ExtensionRegistry::Get(browser_context);
-  if (!registry)
+  if (!registry) {
     return nullptr;
+  }
   std::string extension_id = url.host();
   return registry->enabled_extensions().GetByID(extension_id);
 }
diff --git a/libcef/browser/extensions/chrome_api_registration.cc b/libcef/browser/extensions/chrome_api_registration.cc
index 23d15c75a..d399a9c08 100644
--- a/libcef/browser/extensions/chrome_api_registration.cc
+++ b/libcef/browser/extensions/chrome_api_registration.cc
@@ -66,8 +66,9 @@ const char* const kSupportedAPIs[] = {
 // static
 bool ChromeFunctionRegistry::IsSupported(const std::string& name) {
   for (size_t i = 0; kSupportedAPIs[i] != nullptr; ++i) {
-    if (name == kSupportedAPIs[i])
+    if (name == kSupportedAPIs[i]) {
       return true;
+    }
   }
   return false;
 }
diff --git a/libcef/browser/extensions/extension_function_details.cc b/libcef/browser/extensions/extension_function_details.cc
index 5b96534be..7b5126442 100644
--- a/libcef/browser/extensions/extension_function_details.cc
+++ b/libcef/browser/extensions/extension_function_details.cc
@@ -148,8 +148,9 @@ Profile* CefExtensionFunctionDetails::GetProfile() const {
 CefRefPtr<AlloyBrowserHostImpl> CefExtensionFunctionDetails::GetSenderBrowser()
     const {
   content::WebContents* web_contents = function_->GetSenderWebContents();
-  if (web_contents)
+  if (web_contents) {
     return AlloyBrowserHostImpl::GetBrowserForContents(web_contents);
+  }
   return nullptr;
 }
 
@@ -293,20 +294,23 @@ std::unique_ptr<api::tabs::Tab> CefExtensionFunctionDetails::OpenTab(
     bool user_gesture,
     std::string* error_message) const {
   CefRefPtr<AlloyBrowserHostImpl> sender_browser = GetSenderBrowser();
-  if (!sender_browser)
+  if (!sender_browser) {
     return nullptr;
+  }
 
   // windowId defaults to "current" window.
   int window_id = extension_misc::kCurrentWindowId;
-  if (params.window_id.has_value())
+  if (params.window_id.has_value()) {
     window_id = *params.window_id;
+  }
 
   // CEF doesn't have the concept of windows containing tab strips so we'll
   // select an "active browser" for BrowserContext sharing instead.
   CefRefPtr<AlloyBrowserHostImpl> active_browser =
       GetBrowserForTabIdFirstTime(window_id, error_message);
-  if (!active_browser)
+  if (!active_browser) {
     return nullptr;
+  }
 
   // If an opener browser was specified then we expect it to exist.
   int opener_browser_id = -1;
@@ -330,13 +334,15 @@ std::unique_ptr<api::tabs::Tab> CefExtensionFunctionDetails::OpenTab(
   // Default to foreground for the new tab. The presence of 'active' property
   // will override this default.
   bool active = true;
-  if (params.active.has_value())
+  if (params.active.has_value()) {
     active = *params.active;
+  }
 
   // CEF doesn't use the index value but we let the client see/modify it.
   int index = 0;
-  if (params.index.has_value())
+  if (params.index.has_value()) {
     index = *params.index;
+  }
 
   auto cef_browser_context = CefBrowserContext::FromBrowserContext(
       active_browser->GetBrowserContext());
@@ -345,15 +351,17 @@ std::unique_ptr<api::tabs::Tab> CefExtensionFunctionDetails::OpenTab(
   CefRefPtr<CefExtension> cef_extension =
       cef_browser_context->GetExtension(function()->extension()->id());
   DCHECK(cef_extension);
-  if (!cef_extension)
+  if (!cef_extension) {
     return nullptr;
+  }
 
   // Always use the same request context that the extension was registered with.
   // GetLoaderContext() will return NULL for internal extensions.
   CefRefPtr<CefRequestContext> request_context =
       cef_extension->GetLoaderContext();
-  if (!request_context)
+  if (!request_context) {
     return nullptr;
+  }
 
   CefBrowserCreateParams create_params;
   create_params.url = url.spec();
@@ -387,8 +395,9 @@ std::unique_ptr<api::tabs::Tab> CefExtensionFunctionDetails::OpenTab(
   // Browser creation may fail under certain rare circumstances.
   CefRefPtr<AlloyBrowserHostImpl> new_browser =
       AlloyBrowserHostImpl::Create(create_params);
-  if (!new_browser)
+  if (!new_browser) {
     return nullptr;
+  }
 
   // Return data about the newly created tab.
   auto extension = function()->extension();
@@ -436,8 +445,9 @@ api::tabs::Tab CefExtensionFunctionDetails::CreateTabObject(
     tab_object.fav_icon_url = entry->GetFavicon().url.spec();
   }
 
-  if (opener_browser_id >= 0)
+  if (opener_browser_id >= 0) {
     tab_object.opener_tab_id = opener_browser_id;
+  }
 
   return tab_object;
 }
diff --git a/libcef/browser/extensions/extension_system.cc b/libcef/browser/extensions/extension_system.cc
index 460378fbe..69d0848ec 100644
--- a/libcef/browser/extensions/extension_system.cc
+++ b/libcef/browser/extensions/extension_system.cc
@@ -76,8 +76,9 @@ std::unique_ptr<base::DictionaryValue> ParseManifest(
 
 void ExecuteLoadFailure(CefRefPtr<CefExtensionHandler> handler,
                         cef_errorcode_t result) {
-  if (!handler)
+  if (!handler) {
     return;
+  }
 
   if (!CEF_CURRENTLY_ON_UIT()) {
     CEF_POST_TASK(CEF_UIT, base::BindOnce(ExecuteLoadFailure, handler, result));
@@ -313,8 +314,9 @@ void CefExtensionSystem::LoadExtension(
 
   ComponentExtensionInfo info(manifest.get(), root_directory, internal);
   const Extension* extension = LoadExtension(info, loader_context, handler);
-  if (!extension)
+  if (!extension) {
     ExecuteLoadFailure(handler, ERR_FAILED);
+  }
 }
 
 // Implementation based on ExtensionService::RemoveComponentExtension.
@@ -353,8 +355,9 @@ CefRefPtr<CefExtension> CefExtensionSystem::GetExtension(
     const std::string& extension_id) const {
   CEF_REQUIRE_UIT();
   ExtensionMap::const_iterator it = extension_map_.find(extension_id);
-  if (it != extension_map_.end())
+  if (it != extension_map_.end()) {
     return it->second;
+  }
   return nullptr;
 }
 
@@ -374,8 +377,9 @@ void CefExtensionSystem::OnRequestContextDeleted(CefRequestContext* context) {
   for (; it != map.end(); ++it) {
     CefRefPtr<CefExtensionImpl> cef_extension =
         static_cast<CefExtensionImpl*>(it->second.get());
-    if (cef_extension->loader_context() == context)
+    if (cef_extension->loader_context() == context) {
       UnloadExtension(it->first);
+    }
   }
 }
 
@@ -434,8 +438,9 @@ CefExtensionSystem::store_factory() {
 }
 
 InfoMap* CefExtensionSystem::info_map() {
-  if (!info_map_.get())
+  if (!info_map_.get()) {
     info_map_ = new InfoMap;
+  }
   return info_map_.get();
 }
 
@@ -686,8 +691,9 @@ void CefExtensionSystem::NotifyExtensionLoaded(const Extension* extension) {
 void CefExtensionSystem::OnExtensionRegisteredWithRequestContexts(
     scoped_refptr<const extensions::Extension> extension) {
   registry_->AddReady(extension);
-  if (registry_->enabled_extensions().Contains(extension->id()))
+  if (registry_->enabled_extensions().Contains(extension->id())) {
     registry_->TriggerOnReady(extension.get());
+  }
 }
 
 // Implementation based on ExtensionService::NotifyExtensionUnloaded.
diff --git a/libcef/browser/extensions/extension_view_host.cc b/libcef/browser/extensions/extension_view_host.cc
index ed748cc80..8f2b19f34 100644
--- a/libcef/browser/extensions/extension_view_host.cc
+++ b/libcef/browser/extensions/extension_view_host.cc
@@ -72,8 +72,9 @@ bool CefExtensionViewHost::PreHandleGestureEvent(
 }
 
 WebContents* CefExtensionViewHost::GetVisibleWebContents() const {
-  if (extension_host_type() == mojom::ViewType::kExtensionPopup)
+  if (extension_host_type() == mojom::ViewType::kExtensionPopup) {
     return host_contents();
+  }
   return nullptr;
 }
 
diff --git a/libcef/browser/extensions/extension_web_contents_observer.cc b/libcef/browser/extensions/extension_web_contents_observer.cc
index 25cee0c5e..6e50ebea2 100644
--- a/libcef/browser/extensions/extension_web_contents_observer.cc
+++ b/libcef/browser/extensions/extension_web_contents_observer.cc
@@ -37,8 +37,9 @@ void CefExtensionWebContentsObserver::RenderFrameCreated(
   ExtensionWebContentsObserver::RenderFrameCreated(render_frame_host);
 
   const Extension* extension = GetExtensionFromFrame(render_frame_host, false);
-  if (!extension)
+  if (!extension) {
     return;
+  }
 
   int process_id = render_frame_host->GetProcess()->GetID();
   auto policy = content::ChildProcessSecurityPolicy::GetInstance();
diff --git a/libcef/browser/extensions/extensions_api_client.cc b/libcef/browser/extensions/extensions_api_client.cc
index c4b9a4b67..1d385ca91 100644
--- a/libcef/browser/extensions/extensions_api_client.cc
+++ b/libcef/browser/extensions/extensions_api_client.cc
@@ -75,8 +75,9 @@ void CefExtensionsAPIClient::AddAdditionalValueStoreCaches(
 }
 
 FileSystemDelegate* CefExtensionsAPIClient::GetFileSystemDelegate() {
-  if (!file_system_delegate_)
+  if (!file_system_delegate_) {
     file_system_delegate_ = std::make_unique<cef::CefFileSystemDelegate>();
+  }
   return file_system_delegate_.get();
 }
 
diff --git a/libcef/browser/extensions/extensions_browser_api_provider.cc b/libcef/browser/extensions/extensions_browser_api_provider.cc
index 0c1c1a751..5abc340d7 100644
--- a/libcef/browser/extensions/extensions_browser_api_provider.cc
+++ b/libcef/browser/extensions/extensions_browser_api_provider.cc
@@ -5,7 +5,7 @@
 #include "libcef/browser/extensions/extensions_browser_api_provider.h"
 #include "libcef/browser/extensions/chrome_api_registration.h"
 
-//#include "cef/libcef/browser/extensions/api/generated_api_registration.h"
+// #include "cef/libcef/browser/extensions/api/generated_api_registration.h"
 #include "extensions/browser/api/generated_api_registration.h"
 
 namespace extensions {
diff --git a/libcef/browser/extensions/extensions_browser_client.cc b/libcef/browser/extensions/extensions_browser_client.cc
index 9a360c9be..1ea11c5e7 100644
--- a/libcef/browser/extensions/extensions_browser_client.cc
+++ b/libcef/browser/extensions/extensions_browser_client.cc
@@ -49,13 +49,15 @@ void BindMimeHandlerService(
     mojo::PendingReceiver<extensions::mime_handler::MimeHandlerService>
         receiver) {
   auto* web_contents = content::WebContents::FromRenderFrameHost(frame_host);
-  if (!web_contents)
+  if (!web_contents) {
     return;
+  }
 
   auto* guest_view =
       extensions::MimeHandlerViewGuest::FromWebContents(web_contents);
-  if (!guest_view)
+  if (!guest_view) {
     return;
+  }
   extensions::MimeHandlerServiceImpl::Create(guest_view->GetStreamWeakPtr(),
                                              std::move(receiver));
 }
@@ -65,13 +67,15 @@ void BindBeforeUnloadControl(
     mojo::PendingReceiver<extensions::mime_handler::BeforeUnloadControl>
         receiver) {
   auto* web_contents = content::WebContents::FromRenderFrameHost(frame_host);
-  if (!web_contents)
+  if (!web_contents) {
     return;
+  }
 
   auto* guest_view =
       extensions::MimeHandlerViewGuest::FromWebContents(web_contents);
-  if (!guest_view)
+  if (!guest_view) {
     return;
+  }
   guest_view->FuseBeforeUnloadControl(std::move(receiver));
 }
 
@@ -138,8 +142,9 @@ BrowserContext* CefExtensionsBrowserClient::GetOffTheRecordContext(
 BrowserContext* CefExtensionsBrowserClient::GetOriginalContext(
     BrowserContext* context) {
   auto cef_browser_context = CefBrowserContext::FromBrowserContext(context);
-  if (cef_browser_context)
+  if (cef_browser_context) {
     return cef_browser_context->AsBrowserContext();
+  }
   return nullptr;
 }
 
@@ -393,8 +398,9 @@ CefExtensionsBrowserClient::GetExtensionWebContentsObserver(
 }
 
 KioskDelegate* CefExtensionsBrowserClient::GetKioskDelegate() {
-  if (!kiosk_delegate_)
+  if (!kiosk_delegate_) {
     kiosk_delegate_.reset(new CefKioskDelegate());
+  }
   return kiosk_delegate_.get();
 }
 
diff --git a/libcef/browser/extensions/value_store/cef_value_store.cc b/libcef/browser/extensions/value_store/cef_value_store.cc
index 2e2089bbb..ee1153b16 100644
--- a/libcef/browser/extensions/value_store/cef_value_store.cc
+++ b/libcef/browser/extensions/value_store/cef_value_store.cc
@@ -57,8 +57,9 @@ ValueStore::ReadResult CefValueStore::Get(const std::string& key) {
 ValueStore::ReadResult CefValueStore::Get(
     const std::vector<std::string>& keys) {
   read_count_++;
-  if (!status_.ok())
+  if (!status_.ok()) {
     return ReadResult(CreateStatusCopy(status_));
+  }
 
   base::Value::Dict settings;
   for (const auto& key : keys) {
@@ -72,8 +73,9 @@ ValueStore::ReadResult CefValueStore::Get(
 
 ValueStore::ReadResult CefValueStore::Get() {
   read_count_++;
-  if (!status_.ok())
+  if (!status_.ok()) {
     return ReadResult(CreateStatusCopy(status_));
+  }
   return ReadResult(storage_.Clone(), CreateStatusCopy(status_));
 }
 
@@ -88,8 +90,9 @@ ValueStore::WriteResult CefValueStore::Set(WriteOptions options,
 ValueStore::WriteResult CefValueStore::Set(WriteOptions options,
                                            const base::Value::Dict& settings) {
   write_count_++;
-  if (!status_.ok())
+  if (!status_.ok()) {
     return WriteResult(CreateStatusCopy(status_));
+  }
 
   ValueStoreChangeList changes;
   for (const auto [key, value] : settings) {
@@ -113,8 +116,9 @@ ValueStore::WriteResult CefValueStore::Remove(const std::string& key) {
 ValueStore::WriteResult CefValueStore::Remove(
     const std::vector<std::string>& keys) {
   write_count_++;
-  if (!status_.ok())
+  if (!status_.ok()) {
     return WriteResult(CreateStatusCopy(status_));
+  }
 
   ValueStoreChangeList changes;
   for (auto const& key : keys) {
diff --git a/libcef/browser/extensions/value_store/cef_value_store_factory.cc b/libcef/browser/extensions/value_store/cef_value_store_factory.cc
index 01b06975b..b655210ad 100644
--- a/libcef/browser/extensions/value_store/cef_value_store_factory.cc
+++ b/libcef/browser/extensions/value_store/cef_value_store_factory.cc
@@ -63,10 +63,11 @@ void CefValueStoreFactory::Reset() {
 
 std::unique_ptr<ValueStore> CefValueStoreFactory::CreateStore() {
   std::unique_ptr<ValueStore> store;
-  if (db_path_.empty())
+  if (db_path_.empty()) {
     store = std::make_unique<CefValueStore>();
-  else
+  } else {
     store = std::make_unique<LeveldbValueStore>(kUMAClientName, db_path_);
+  }
   last_created_store_ = store.get();
   return store;
 }
diff --git a/libcef/browser/file_dialog_manager.cc b/libcef/browser/file_dialog_manager.cc
index fee3af3ce..2e4508986 100644
--- a/libcef/browser/file_dialog_manager.cc
+++ b/libcef/browser/file_dialog_manager.cc
@@ -47,8 +47,9 @@ class CefFileDialogCallbackImpl : public CefFileDialogCallback {
         std::vector<base::FilePath> vec;
         if (!file_paths.empty()) {
           std::vector<CefString>::const_iterator it = file_paths.begin();
-          for (; it != file_paths.end(); ++it)
+          for (; it != file_paths.end(); ++it) {
             vec.push_back(base::FilePath(*it));
+          }
         }
         std::move(callback_).Run(vec);
       }
@@ -88,8 +89,9 @@ void RunFileDialogDismissed(CefRefPtr<CefRunFileDialogCallback> callback,
                             const std::vector<base::FilePath>& file_paths) {
   std::vector<CefString> paths;
   if (file_paths.size() > 0) {
-    for (size_t i = 0; i < file_paths.size(); ++i)
+    for (size_t i = 0; i < file_paths.size(); ++i) {
       paths.push_back(file_paths[i].value());
+    }
   }
   callback->OnFileDialogDismissed(paths);
 }
@@ -298,8 +300,9 @@ void CefFileDialogManager::RunFileDialog(
     const std::vector<CefString>& accept_filters,
     CefRefPtr<CefRunFileDialogCallback> callback) {
   DCHECK(callback.get());
-  if (!callback.get())
+  if (!callback.get()) {
     return;
+  }
 
   blink::mojom::FileChooserParams params;
   switch (mode) {
@@ -318,13 +321,15 @@ void CefFileDialogManager::RunFileDialog(
   }
 
   params.title = title;
-  if (!default_file_path.empty())
+  if (!default_file_path.empty()) {
     params.default_file_name = base::FilePath(default_file_path);
+  }
 
   if (!accept_filters.empty()) {
     std::vector<CefString>::const_iterator it = accept_filters.begin();
-    for (; it != accept_filters.end(); ++it)
+    for (; it != accept_filters.end(); ++it) {
       params.accept_types.push_back(*it);
+    }
   }
 
   RunFileChooser(params, base::BindOnce(RunFileDialogDismissed, callback));
@@ -493,8 +498,9 @@ CefFileDialogManager::MaybeRunDelegate(
 
       std::vector<CefString> accept_filters;
       it = params.accept_types.begin();
-      for (; it != params.accept_types.end(); ++it)
+      for (; it != params.accept_types.end(); ++it) {
         accept_filters.push_back(*it);
+      }
 
       CefRefPtr<CefFileDialogCallbackImpl> callbackImpl(
           new CefFileDialogCallbackImpl(std::move(callback)));
@@ -519,8 +525,9 @@ void CefFileDialogManager::SelectFileDoneByDelegateCallback(
 
   // The listener may already be gone. This can occur if the client holds a
   // RunFileChooserCallback past the call to SelectFileListenerDestroyed().
-  if (active_listeners_.find(listener) == active_listeners_.end())
+  if (active_listeners_.find(listener) == active_listeners_.end()) {
     return;
+  }
 
   active_listeners_.erase(listener);
 
@@ -545,8 +552,9 @@ void CefFileDialogManager::SelectFileDoneByListenerCallback(
   // CefSelectFileDialogListener::Destroy(). Similarly, the below call to
   // Cancel() may trigger another execution from
   // CefSelectFileDialogListener::Destroy().
-  if (!dialog_listener_)
+  if (!dialog_listener_) {
     return;
+  }
 
   DCHECK(dialog_);
   DCHECK(dialog_listener_);
diff --git a/libcef/browser/file_dialog_runner.cc b/libcef/browser/file_dialog_runner.cc
index a9fc3318b..40eb2a338 100644
--- a/libcef/browser/file_dialog_runner.cc
+++ b/libcef/browser/file_dialog_runner.cc
@@ -130,8 +130,9 @@ class CefSelectFileDialog final : public ui::SelectFileDialog {
   }
 
   void ListenerDestroyed() override {
-    if (browser_)
+    if (browser_) {
       browser_->SelectFileListenerDestroyed(listener_);
+    }
     listener_ = nullptr;
   }
 
diff --git a/libcef/browser/frame_host_impl.cc b/libcef/browser/frame_host_impl.cc
index df3b83ced..c80de56e5 100644
--- a/libcef/browser/frame_host_impl.cc
+++ b/libcef/browser/frame_host_impl.cc
@@ -177,14 +177,16 @@ CefRefPtr<CefFrame> CefFrameHostImpl::GetParent() {
 
   {
     base::AutoLock lock_scope(state_lock_);
-    if (is_main_frame_ || parent_frame_id_ == kInvalidFrameId)
+    if (is_main_frame_ || parent_frame_id_ == kInvalidFrameId) {
       return nullptr;
+    }
     parent_frame_id = parent_frame_id_;
   }
 
   auto browser = GetBrowserHostBase();
-  if (browser)
+  if (browser) {
     return browser->GetFrame(parent_frame_id);
+  }
 
   return nullptr;
 }
@@ -210,8 +212,9 @@ void CefFrameHostImpl::VisitDOM(CefRefPtr<CefDOMVisitor> visitor) {
 CefRefPtr<CefURLRequest> CefFrameHostImpl::CreateURLRequest(
     CefRefPtr<CefRequest> request,
     CefRefPtr<CefURLRequestClient> client) {
-  if (!request || !client)
+  if (!request || !client) {
     return nullptr;
+  }
 
   if (!CefTaskRunnerImpl::GetCurrentTaskRunner()) {
     NOTREACHED() << "called on invalid thread";
@@ -219,15 +222,17 @@ CefRefPtr<CefURLRequest> CefFrameHostImpl::CreateURLRequest(
   }
 
   auto browser = GetBrowserHostBase();
-  if (!browser)
+  if (!browser) {
     return nullptr;
+  }
 
   auto request_context = browser->request_context();
 
   CefRefPtr<CefBrowserURLRequest> impl =
       new CefBrowserURLRequest(this, request, client, request_context);
-  if (impl->Start())
+  if (impl->Start()) {
     return impl.get();
+  }
   return nullptr;
 }
 
@@ -236,8 +241,9 @@ void CefFrameHostImpl::SendProcessMessage(
     CefRefPtr<CefProcessMessage> message) {
   DCHECK_EQ(PID_RENDERER, target_process);
   DCHECK(message && message->IsValid());
-  if (!message || !message->IsValid())
+  if (!message || !message->IsValid()) {
     return;
+  }
 
   if (message->GetArgumentList() != nullptr) {
     // Invalidate the message object immediately by taking the argument list.
@@ -275,8 +281,9 @@ void CefFrameHostImpl::RefreshAttributes() {
   CEF_REQUIRE_UIT();
 
   base::AutoLock lock_scope(state_lock_);
-  if (!render_frame_host_)
+  if (!render_frame_host_) {
     return;
+  }
   url_ = render_frame_host_->GetLastCommittedURL().spec();
 
   // Use the assigned name if it is non-empty. This represents the name property
@@ -298,8 +305,9 @@ void CefFrameHostImpl::RefreshAttributes() {
 }
 
 void CefFrameHostImpl::LoadRequest(cef::mojom::RequestParamsPtr params) {
-  if (!url_util::FixupGURL(params->url))
+  if (!url_util::FixupGURL(params->url)) {
     return;
+  }
 
   SendToRenderFrame(__FUNCTION__,
                     base::BindOnce(
@@ -310,8 +318,9 @@ void CefFrameHostImpl::LoadRequest(cef::mojom::RequestParamsPtr params) {
                         std::move(params)));
 
   auto browser = GetBrowserHostBase();
-  if (browser)
+  if (browser) {
     browser->OnSetFocus(FOCUS_SOURCE_NAVIGATION);
+  }
 }
 
 void CefFrameHostImpl::LoadURLWithExtras(const std::string& url,
@@ -320,8 +329,9 @@ void CefFrameHostImpl::LoadURLWithExtras(const std::string& url,
                                          const std::string& extra_headers) {
   // Only known frame ids or kMainFrameId are supported.
   const auto frame_id = GetFrameId();
-  if (frame_id < CefFrameHostImpl::kMainFrameId)
+  if (frame_id < CefFrameHostImpl::kMainFrameId) {
     return;
+  }
 
   // Any necessary fixup will occur in LoadRequest.
   GURL gurl = url_util::MakeGURL(url, /*fixup=*/false);
@@ -378,8 +388,9 @@ void CefFrameHostImpl::SendCommandWithResponse(
 void CefFrameHostImpl::SendJavaScript(const std::u16string& jsCode,
                                       const std::string& scriptUrl,
                                       int startLine) {
-  if (jsCode.empty())
+  if (jsCode.empty()) {
     return;
+  }
   if (startLine <= 0) {
     // A value of 0 is v8::Message::kNoLineNumberInfo in V8. There is code in
     // V8 that will assert on that value (e.g. V8StackTraceImpl::Frame::Frame
@@ -399,8 +410,9 @@ void CefFrameHostImpl::SendJavaScript(const std::u16string& jsCode,
 
 void CefFrameHostImpl::MaybeSendDidStopLoading() {
   auto rfh = GetRenderFrameHost();
-  if (!rfh)
+  if (!rfh) {
     return;
+  }
 
   // We only want to notify for the highest-level LocalFrame in this frame's
   // renderer process subtree. If this frame has a parent in the same process
@@ -541,8 +553,9 @@ scoped_refptr<CefBrowserInfo> CefFrameHostImpl::GetBrowserInfo() const {
 }
 
 CefRefPtr<CefBrowserHostBase> CefFrameHostImpl::GetBrowserHostBase() const {
-  if (auto browser_info = GetBrowserInfo())
+  if (auto browser_info = GetBrowserInfo()) {
     return browser_info->browser();
+  }
   return nullptr;
 }
 
@@ -650,8 +663,9 @@ void CefFrameHostImpl::FrameAttached(
 void CefFrameHostImpl::UpdateDraggableRegions(
     absl::optional<std::vector<cef::mojom::DraggableRegionEntryPtr>> regions) {
   auto browser = GetBrowserHostBase();
-  if (!browser)
+  if (!browser) {
     return;
+  }
 
   std::vector<CefDraggableRegion> draggable_regions;
   if (regions) {
@@ -679,6 +693,7 @@ std::string CefFrameHostImpl::GetDebugString() const {
 void CefExecuteJavaScriptWithUserGestureForTests(CefRefPtr<CefFrame> frame,
                                                  const CefString& javascript) {
   CefFrameHostImpl* impl = static_cast<CefFrameHostImpl*>(frame.get());
-  if (impl)
+  if (impl) {
     impl->ExecuteJavaScriptWithUserGestureForTests(javascript);
+  }
 }
diff --git a/libcef/browser/frame_service_base.h b/libcef/browser/frame_service_base.h
index ac3b50a03..16ae94698 100644
--- a/libcef/browser/frame_service_base.h
+++ b/libcef/browser/frame_service_base.h
@@ -85,8 +85,9 @@ class FrameServiceBase : public Interface, public WebContentsObserver {
 
   void DidFinishNavigation(NavigationHandle* navigation_handle) final {
     DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
-    if (!ShouldCloseOnFinishNavigation())
+    if (!ShouldCloseOnFinishNavigation()) {
       return;
+    }
 
     if (!navigation_handle->HasCommitted() ||
         navigation_handle->IsSameDocument() ||
diff --git a/libcef/browser/image_impl.cc b/libcef/browser/image_impl.cc
index 9d82331f8..20a3cd0e1 100644
--- a/libcef/browser/image_impl.cc
+++ b/libcef/browser/image_impl.cc
@@ -85,12 +85,14 @@ bool CefImageImpl::IsEmpty() {
 
 bool CefImageImpl::IsSame(CefRefPtr<CefImage> that) {
   CefImageImpl* that_impl = static_cast<CefImageImpl*>(that.get());
-  if (!that_impl)
+  if (!that_impl) {
     return false;
+  }
 
   // Quick check for the same object.
-  if (this == that_impl)
+  if (this == that_impl) {
     return true;
+  }
 
   base::AutoLock lock_scope(lock_);
   return image_.AsImageSkia().BackedBySameObjectAs(
@@ -108,10 +110,12 @@ bool CefImageImpl::AddBitmap(float scale_factor,
   const SkAlphaType at = GetSkAlphaType(alpha_type);
 
   // Make sure the client passed in the expected values.
-  if (ct != kBGRA_8888_SkColorType && ct != kRGBA_8888_SkColorType)
+  if (ct != kBGRA_8888_SkColorType && ct != kRGBA_8888_SkColorType) {
     return false;
-  if (pixel_data_size != pixel_width * pixel_height * 4U)
+  }
+  if (pixel_data_size != pixel_width * pixel_height * 4U) {
     return false;
+  }
 
   SkBitmap bitmap;
   if (!bitmap.tryAllocPixels(
@@ -142,8 +146,9 @@ bool CefImageImpl::AddJPEG(float scale_factor,
                            size_t jpeg_data_size) {
   std::unique_ptr<SkBitmap> bitmap(gfx::JPEGCodec::Decode(
       static_cast<const unsigned char*>(jpeg_data), jpeg_data_size));
-  if (!bitmap.get())
+  if (!bitmap.get()) {
     return false;
+  }
 
   return AddBitmap(scale_factor, *bitmap);
 }
@@ -179,12 +184,14 @@ bool CefImageImpl::GetRepresentationInfo(float scale_factor,
                                          int& pixel_height) {
   base::AutoLock lock_scope(lock_);
   gfx::ImageSkia image_skia = image_.AsImageSkia();
-  if (image_skia.isNull())
+  if (image_skia.isNull()) {
     return false;
+  }
 
   const gfx::ImageSkiaRep& rep = image_skia.GetRepresentation(scale_factor);
-  if (rep.is_null())
+  if (rep.is_null()) {
     return false;
+  }
 
   actual_scale_factor = rep.scale();
   pixel_width = rep.GetBitmap().width();
@@ -202,8 +209,9 @@ CefRefPtr<CefBinaryValue> CefImageImpl::GetAsBitmap(float scale_factor,
 
   base::AutoLock lock_scope(lock_);
   const SkBitmap* bitmap = GetBitmap(scale_factor);
-  if (!bitmap)
+  if (!bitmap) {
     return nullptr;
+  }
 
   DCHECK(bitmap->readyToDraw());
 
@@ -216,8 +224,9 @@ CefRefPtr<CefBinaryValue> CefImageImpl::GetAsBitmap(float scale_factor,
                                   bitmap->computeByteSize());
   } else {
     SkBitmap desired_bitmap;
-    if (!ConvertBitmap(*bitmap, &desired_bitmap, desired_ct, desired_at))
+    if (!ConvertBitmap(*bitmap, &desired_bitmap, desired_ct, desired_at)) {
       return nullptr;
+    }
     DCHECK(desired_bitmap.readyToDraw());
     return CefBinaryValue::Create(desired_bitmap.getPixels(),
                                   desired_bitmap.computeByteSize());
@@ -230,12 +239,14 @@ CefRefPtr<CefBinaryValue> CefImageImpl::GetAsPNG(float scale_factor,
                                                  int& pixel_height) {
   base::AutoLock lock_scope(lock_);
   const SkBitmap* bitmap = GetBitmap(scale_factor);
-  if (!bitmap)
+  if (!bitmap) {
     return nullptr;
+  }
 
   std::vector<unsigned char> compressed;
-  if (!WritePNG(*bitmap, &compressed, with_transparency))
+  if (!WritePNG(*bitmap, &compressed, with_transparency)) {
     return nullptr;
+  }
 
   pixel_width = bitmap->width();
   pixel_height = bitmap->height();
@@ -249,12 +260,14 @@ CefRefPtr<CefBinaryValue> CefImageImpl::GetAsJPEG(float scale_factor,
                                                   int& pixel_height) {
   base::AutoLock lock_scope(lock_);
   const SkBitmap* bitmap = GetBitmap(scale_factor);
-  if (!bitmap)
+  if (!bitmap) {
     return nullptr;
+  }
 
   std::vector<unsigned char> compressed;
-  if (!WriteJPEG(*bitmap, &compressed, quality))
+  if (!WriteJPEG(*bitmap, &compressed, quality)) {
     return nullptr;
+  }
 
   pixel_width = bitmap->width();
   pixel_height = bitmap->height();
@@ -269,8 +282,9 @@ void CefImageImpl::AddBitmaps(int32_t scale_1x_size,
     int32_t min_size = std::numeric_limits<int32_t>::max();
     for (const SkBitmap& bitmap : bitmaps) {
       const int32_t size = std::max(bitmap.width(), bitmap.height());
-      if (size < min_size)
+      if (size < min_size) {
         min_size = size;
+      }
     }
     scale_1x_size = min_size;
   }
@@ -293,8 +307,9 @@ gfx::ImageSkia CefImageImpl::GetForced1xScaleRepresentation(
 
   const SkBitmap* bitmap = GetBitmap(scale_factor);
   gfx::ImageSkia image_skia;
-  if (bitmap)
+  if (bitmap) {
     image_skia.AddRepresentation(gfx::ImageSkiaRep(*bitmap, 1.0f));
+  }
   return image_skia;
 }
 
@@ -315,8 +330,9 @@ bool CefImageImpl::AddBitmap(float scale_factor, const SkBitmap& bitmap) {
   // CHECKs in ImageSkiaRep and eventual conversion to N32 at some later point
   // in the compositing pipeline.
   SkBitmap n32_bitmap;
-  if (!skia::SkBitmapToN32OpaqueOrPremul(bitmap, &n32_bitmap))
+  if (!skia::SkBitmapToN32OpaqueOrPremul(bitmap, &n32_bitmap)) {
     return false;
+  }
 
   gfx::ImageSkiaRep skia_rep(n32_bitmap, scale_factor);
   base::AutoLock lock_scope(lock_);
@@ -331,12 +347,14 @@ bool CefImageImpl::AddBitmap(float scale_factor, const SkBitmap& bitmap) {
 const SkBitmap* CefImageImpl::GetBitmap(float scale_factor) const {
   lock_.AssertAcquired();
   gfx::ImageSkia image_skia = image_.AsImageSkia();
-  if (image_skia.isNull())
+  if (image_skia.isNull()) {
     return nullptr;
+  }
 
   const gfx::ImageSkiaRep& rep = image_skia.GetRepresentation(scale_factor);
-  if (rep.is_null())
+  if (rep.is_null()) {
     return nullptr;
+  }
 
   return &rep.GetBitmap();
 }
@@ -353,8 +371,9 @@ bool CefImageImpl::ConvertBitmap(const SkBitmap& src_bitmap,
 
   SkImageInfo target_info = SkImageInfo::Make(
       src_bitmap.width(), src_bitmap.height(), target_ct, target_at);
-  if (!target_bitmap->tryAllocPixels(target_info))
+  if (!target_bitmap->tryAllocPixels(target_info)) {
     return false;
+  }
 
   if (!src_bitmap.readPixels(target_info, target_bitmap->getPixels(),
                              target_bitmap->rowBytes(), 0, 0)) {
diff --git a/libcef/browser/iothread_state.cc b/libcef/browser/iothread_state.cc
index 4f731e979..4b4d3b169 100644
--- a/libcef/browser/iothread_state.cc
+++ b/libcef/browser/iothread_state.cc
@@ -72,8 +72,9 @@ void CefIOThreadState::RegisterSchemeHandlerFactory(
   } else {
     // Remove the existing factory, if any.
     auto it = scheme_handler_factory_map_.find(key);
-    if (it != scheme_handler_factory_map_.end())
+    if (it != scheme_handler_factory_map_.end()) {
       scheme_handler_factory_map_.erase(it);
+    }
   }
 }
 
@@ -90,8 +91,9 @@ CefRefPtr<CefSchemeHandlerFactory> CefIOThreadState::GetSchemeHandlerFactory(
     const GURL& url) {
   CEF_REQUIRE_IOT();
 
-  if (scheme_handler_factory_map_.empty())
+  if (scheme_handler_factory_map_.empty()) {
     return nullptr;
+  }
 
   const std::string& scheme_lower = url.scheme();
   const std::string& domain_lower =
@@ -104,15 +106,17 @@ CefRefPtr<CefSchemeHandlerFactory> CefIOThreadState::GetSchemeHandlerFactory(
     // Try for a match with hostname first.
     const auto it = scheme_handler_factory_map_.find(
         std::make_pair(scheme_lower, domain_lower));
-    if (it != scheme_handler_factory_map_.end())
+    if (it != scheme_handler_factory_map_.end()) {
       return it->second;
+    }
   }
 
   // Try for a match with no specified hostname.
   const auto it = scheme_handler_factory_map_.find(
       std::make_pair(scheme_lower, std::string()));
-  if (it != scheme_handler_factory_map_.end())
+  if (it != scheme_handler_factory_map_.end()) {
     return it->second;
+  }
 
   return nullptr;
 }
diff --git a/libcef/browser/javascript_dialog_manager.cc b/libcef/browser/javascript_dialog_manager.cc
index 8365c06c2..115211f3f 100644
--- a/libcef/browser/javascript_dialog_manager.cc
+++ b/libcef/browser/javascript_dialog_manager.cc
@@ -238,8 +238,9 @@ bool CefJavaScriptDialogManager::HandleJavaScriptDialog(
     return true;
   }
 
-  if (!CanUseChromeDialogs())
+  if (!CanUseChromeDialogs()) {
     return true;
+  }
 
   auto manager = GetTabModalDialogManager(web_contents);
   return manager->HandleJavaScriptDialog(web_contents, accept, prompt_override);
@@ -262,11 +263,13 @@ void CefJavaScriptDialogManager::CancelDialogs(
   }
 
   // Null when called from DialogClosed() or Destroy().
-  if (!web_contents)
+  if (!web_contents) {
     return;
+  }
 
-  if (!CanUseChromeDialogs())
+  if (!CanUseChromeDialogs()) {
     return;
+  }
 
   auto manager = GetTabModalDialogManager(web_contents);
   manager->CancelDialogs(web_contents, reset_state);
diff --git a/libcef/browser/main_runner.cc b/libcef/browser/main_runner.cc
index cf3855691..65d644bc3 100644
--- a/libcef/browser/main_runner.cc
+++ b/libcef/browser/main_runner.cc
@@ -134,8 +134,9 @@ class CefUIThread : public base::PlatformThread::Delegate {
     }
 
     // Can't join if the |thread_| is either already gone or is non-joinable.
-    if (thread_.is_null())
+    if (thread_.is_null()) {
       return;
+    }
 
     base::PlatformThread::Join(thread_);
     thread_ = base::PlatformThreadHandle();
@@ -283,8 +284,9 @@ void CefMainRunner::RunMessageLoop() {
 
 void CefMainRunner::QuitMessageLoop() {
   if (!quit_when_idle_callback_.is_null()) {
-    if (main_delegate_->HandleMainMessageLoopQuit())
+    if (main_delegate_->HandleMainMessageLoopQuit()) {
       return;
+    }
     std::move(quit_when_idle_callback_).Run();
   }
 }
@@ -301,15 +303,17 @@ int CefMainRunner::RunAsHelperProcess(const CefMainArgs& args,
 #endif
 
   // Wait for the debugger as early in process initialization as possible.
-  if (command_line.HasSwitch(switches::kWaitForDebugger))
+  if (command_line.HasSwitch(switches::kWaitForDebugger)) {
     base::debug::WaitForDebugger(60, true);
+  }
 
   // If no process type is specified then it represents the browser process and
   // we do nothing.
   const std::string& process_type =
       command_line.GetSwitchValueASCII(switches::kProcessType);
-  if (process_type.empty())
+  if (process_type.empty()) {
     return -1;
+  }
 
   auto runtime_type = command_line.HasSwitch(switches::kEnableChromeRuntime)
                           ? RuntimeType::CHROME
@@ -436,8 +440,9 @@ int CefMainRunner::RunMainProcess(
     // loop.
     int exit_code =
         browser_runner_->Initialize(std::move(main_function_params));
-    if (exit_code >= 0)
+    if (exit_code >= 0) {
       return exit_code;
+    }
   } else {
     // Running on the separate UI thread.
     DCHECK(ui_thread_);
@@ -489,8 +494,9 @@ void CefMainRunner::FinishShutdownOnUIThread(
   std::move(shutdown_on_ui_thread).Run();
   main_delegate_->AfterUIThreadShutdown();
 
-  if (uithread_shutdown_event)
+  if (uithread_shutdown_event) {
     uithread_shutdown_event->Signal();
+  }
 }
 
 void CefMainRunner::FinalizeShutdown(base::OnceClosure finalize_shutdown) {
diff --git a/libcef/browser/media_access_query.cc b/libcef/browser/media_access_query.cc
index 82498f388..0e58b2bfc 100644
--- a/libcef/browser/media_access_query.cc
+++ b/libcef/browser/media_access_query.cc
@@ -172,10 +172,12 @@ class CefMediaAccessQuery {
         *stream_devices_set->stream_devices[0];
 
     // At most one audio device and one video device can be used in a stream.
-    if (!audio_devices.empty())
+    if (!audio_devices.empty()) {
       devices.audio_device = audio_devices.front();
-    if (!video_devices.empty())
+    }
+    if (!video_devices.empty()) {
       devices.video_device = video_devices.front();
+    }
 
     return stream_devices_set;
   }
@@ -326,8 +328,9 @@ content::MediaResponseCallback RequestMediaAccessPermission(
       auto frame =
           browser->GetFrameForGlobalId(content::GlobalRenderFrameHostId(
               request.render_process_id, request.render_frame_id));
-      if (!frame)
+      if (!frame) {
         frame = browser->GetMainFrame();
+      }
       handled = handler->OnRequestMediaAccessPermission(
           browser, frame, request.security_origin.spec(), requested_permissions,
           callbackImpl.get());
diff --git a/libcef/browser/media_capture_devices_dispatcher.cc b/libcef/browser/media_capture_devices_dispatcher.cc
index cc2c75e45..25d53017c 100644
--- a/libcef/browser/media_capture_devices_dispatcher.cc
+++ b/libcef/browser/media_capture_devices_dispatcher.cc
@@ -18,8 +18,9 @@ namespace {
 const blink::MediaStreamDevice* FindDefaultDeviceWithId(
     const blink::MediaStreamDevices& devices,
     const std::string& device_id) {
-  if (devices.empty())
+  if (devices.empty()) {
     return nullptr;
+  }
 
   blink::MediaStreamDevices::const_iterator iter = devices.begin();
   for (; iter != devices.end(); ++iter) {
@@ -82,15 +83,17 @@ void CefMediaCaptureDevicesDispatcher::GetRequestedDevice(
     const blink::MediaStreamDevices& audio_devices = GetAudioCaptureDevices();
     const blink::MediaStreamDevice* const device =
         FindDefaultDeviceWithId(audio_devices, requested_device_id);
-    if (device)
+    if (device) {
       devices->push_back(*device);
+    }
   }
   if (video) {
     const blink::MediaStreamDevices& video_devices = GetVideoCaptureDevices();
     const blink::MediaStreamDevice* const device =
         FindDefaultDeviceWithId(video_devices, requested_device_id);
-    if (device)
+    if (device) {
       devices->push_back(*device);
+    }
   }
 }
 
diff --git a/libcef/browser/media_router/media_route_impl.cc b/libcef/browser/media_router/media_route_impl.cc
index 1a3be8f60..243f58542 100644
--- a/libcef/browser/media_router/media_route_impl.cc
+++ b/libcef/browser/media_router/media_route_impl.cc
@@ -70,8 +70,9 @@ void CefMediaRouteImpl::Terminate() {
   }
 
   auto browser_context = GetBrowserContext(browser_context_getter_);
-  if (!browser_context)
+  if (!browser_context) {
     return;
+  }
 
   browser_context->GetMediaRouterManager()->TerminateRoute(
       route_.media_route_id());
@@ -79,8 +80,9 @@ void CefMediaRouteImpl::Terminate() {
 
 void CefMediaRouteImpl::SendRouteMessageInternal(std::string message) {
   auto browser_context = GetBrowserContext(browser_context_getter_);
-  if (!browser_context)
+  if (!browser_context) {
     return;
+  }
 
   browser_context->GetMediaRouterManager()->SendRouteMessage(
       route_.media_route_id(), message);
diff --git a/libcef/browser/media_router/media_router_impl.cc b/libcef/browser/media_router/media_router_impl.cc
index 5cbc5ade9..4955fc767 100644
--- a/libcef/browser/media_router/media_router_impl.cc
+++ b/libcef/browser/media_router/media_router_impl.cc
@@ -38,12 +38,14 @@ class CefRegistrationImpl : public CefRegistration,
     CEF_REQUIRE_UIT();
 
     // May be null if OnMediaRouterDestroyed was called.
-    if (browser_context_getter_.is_null())
+    if (browser_context_getter_.is_null()) {
       return;
+    }
 
     auto browser_context = GetBrowserContext(browser_context_getter_);
-    if (!browser_context)
+    if (!browser_context) {
       return;
+    }
 
     browser_context->GetMediaRouterManager()->RemoveObserver(this);
   }
@@ -55,8 +57,9 @@ class CefRegistrationImpl : public CefRegistration,
     browser_context_getter_ = browser_context_getter;
 
     auto browser_context = GetBrowserContext(browser_context_getter_);
-    if (!browser_context)
+    if (!browser_context) {
       return;
+    }
 
     browser_context->GetMediaRouterManager()->AddObserver(this);
   }
@@ -165,8 +168,9 @@ void CefMediaRouterImpl::Initialize(
 
 CefRefPtr<CefRegistration> CefMediaRouterImpl::AddObserver(
     CefRefPtr<CefMediaObserver> observer) {
-  if (!observer)
+  if (!observer) {
     return nullptr;
+  }
   CefRefPtr<CefRegistrationImpl> registration =
       new CefRegistrationImpl(observer);
   StoreOrTriggerInitCallback(base::BindOnce(
@@ -175,8 +179,9 @@ CefRefPtr<CefRegistration> CefMediaRouterImpl::AddObserver(
 }
 
 CefRefPtr<CefMediaSource> CefMediaRouterImpl::GetSource(const CefString& urn) {
-  if (urn.empty())
+  if (urn.empty()) {
     return nullptr;
+  }
 
   // Check for a valid URL and supported Cast/DIAL schemes.
   GURL presentation_url(urn.ToString());
@@ -222,8 +227,9 @@ void CefMediaRouterImpl::NotifyCurrentSinksInternal() {
   DCHECK(ValidContext());
 
   auto browser_context = GetBrowserContext(browser_context_getter_);
-  if (!browser_context)
+  if (!browser_context) {
     return;
+  }
 
   browser_context->GetMediaRouterManager()->NotifyCurrentSinks();
 }
@@ -268,8 +274,9 @@ void CefMediaRouterImpl::NotifyCurrentRoutesInternal() {
   DCHECK(ValidContext());
 
   auto browser_context = GetBrowserContext(browser_context_getter_);
-  if (!browser_context)
+  if (!browser_context) {
     return;
+  }
 
   browser_context->GetMediaRouterManager()->NotifyCurrentRoutes();
 }
@@ -284,8 +291,9 @@ void CefMediaRouterImpl::CreateRouteCallback(
                  << result.result_code() << ")";
   }
 
-  if (!callback)
+  if (!callback) {
     return;
+  }
 
   CefRefPtr<CefMediaRoute> route;
   if (result.result_code() == media_router::mojom::RouteRequestResultCode::OK &&
diff --git a/libcef/browser/media_router/media_router_manager.cc b/libcef/browser/media_router/media_router_manager.cc
index b93b8b5b8..767fe7c79 100644
--- a/libcef/browser/media_router/media_router_manager.cc
+++ b/libcef/browser/media_router/media_router_manager.cc
@@ -283,14 +283,16 @@ void CefMediaRouterManager::CreateRouteState(
 CefMediaRouterManager::RouteState* CefMediaRouterManager::GetRouteState(
     const media_router::MediaRoute::Id& route_id) {
   const auto it = route_state_map_.find(route_id);
-  if (it != route_state_map_.end())
+  if (it != route_state_map_.end()) {
     return it->second.get();
+  }
   return nullptr;
 }
 
 void CefMediaRouterManager::RemoveRouteState(
     const media_router::MediaRoute::Id& route_id) {
   auto it = route_state_map_.find(route_id);
-  if (it != route_state_map_.end())
+  if (it != route_state_map_.end()) {
     route_state_map_.erase(it);
+  }
 }
diff --git a/libcef/browser/media_router/media_sink_impl.cc b/libcef/browser/media_router/media_sink_impl.cc
index 70a32d975..2b1c0be3a 100644
--- a/libcef/browser/media_router/media_sink_impl.cc
+++ b/libcef/browser/media_router/media_sink_impl.cc
@@ -35,8 +35,9 @@ void GetSinkInternalAndContinue(
 
   for (auto service : services) {
     sink_internal = service->GetSinkById(sink_id);
-    if (sink_internal)
+    if (sink_internal) {
       break;
+    }
   }
 
   if (sink_internal) {
@@ -131,10 +132,12 @@ bool CefMediaSinkImpl::IsDialSink() {
 
 bool CefMediaSinkImpl::IsCompatibleWith(CefRefPtr<CefMediaSource> source) {
   if (source) {
-    if (IsCastSink())
+    if (IsCastSink()) {
       return source->IsCastSource();
-    if (IsDialSink())
+    }
+    if (IsDialSink()) {
       return source->IsDialSource();
+    }
   }
   return false;
 }
diff --git a/libcef/browser/media_stream_registrar.cc b/libcef/browser/media_stream_registrar.cc
index 476c10fae..bdf3dd922 100644
--- a/libcef/browser/media_stream_registrar.cc
+++ b/libcef/browser/media_stream_registrar.cc
@@ -87,10 +87,12 @@ void CefMediaStreamRegistrar::NotifyMediaStreamChange() {
   bool audio = false;
   for (const auto& media_stream : registered_streams_) {
     const auto& info = media_stream.second;
-    if (!video)
+    if (!video) {
       video = info.video;
-    if (!audio)
+    }
+    if (!audio) {
       audio = info.audio;
+    }
   }
 
   if (audio == last_notified_info_.audio &&
diff --git a/libcef/browser/menu_manager.cc b/libcef/browser/menu_manager.cc
index 7ba539424..ccc4fc029 100644
--- a/libcef/browser/menu_manager.cc
+++ b/libcef/browser/menu_manager.cc
@@ -109,13 +109,15 @@ CefMenuManager::~CefMenuManager() {
 
 void CefMenuManager::Destroy() {
   CancelContextMenu();
-  if (runner_)
+  if (runner_) {
     runner_.reset(nullptr);
+  }
 }
 
 bool CefMenuManager::IsShowingContextMenu() {
-  if (!web_contents())
+  if (!web_contents()) {
     return false;
+  }
   return web_contents()->IsShowingContextMenu();
 }
 
@@ -128,8 +130,9 @@ bool CefMenuManager::CreateContextMenu(
   // the second mouse event arrives. In this case, |HandleContextMenu()| will
   // get called multiple times - if so, don't create another context menu.
   // TODO(asvitkine): Fix the renderer so that it doesn't do this.
-  if (IsShowingContextMenu())
+  if (IsShowingContextMenu()) {
     return true;
+  }
 
   params_ = params;
   model_->Clear();
@@ -188,8 +191,9 @@ bool CefMenuManager::CreateContextMenu(
     }
   }
 
-  if (custom_menu)
+  if (custom_menu) {
     return true;
+  }
 
   if (!runner_ || !runner_->RunContextMenu(browser_, model_.get(), params_)) {
     LOG(ERROR) << "Default context menu implementation is not available; "
@@ -201,10 +205,11 @@ bool CefMenuManager::CreateContextMenu(
 
 void CefMenuManager::CancelContextMenu() {
   if (IsShowingContextMenu()) {
-    if (custom_menu_callback_)
+    if (custom_menu_callback_) {
       custom_menu_callback_->Cancel();
-    else if (runner_)
+    } else if (runner_) {
       runner_->CancelContextMenu();
+    }
   }
 }
 
@@ -227,8 +232,9 @@ void CefMenuManager::ExecuteCommand(CefRefPtr<CefMenuModelImpl> source,
       std::ignore = paramsPtr->Detach(nullptr);
       DCHECK(paramsPtr->HasOneRef());
 
-      if (handled)
+      if (handled) {
         return;
+      }
     }
   }
 
@@ -238,15 +244,18 @@ void CefMenuManager::ExecuteCommand(CefRefPtr<CefMenuModelImpl> source,
 
 void CefMenuManager::MenuWillShow(CefRefPtr<CefMenuModelImpl> source) {
   // May be called for sub-menus as well.
-  if (source.get() != model_.get())
+  if (source.get() != model_.get()) {
     return;
+  }
 
-  if (!web_contents())
+  if (!web_contents()) {
     return;
+  }
 
   // May be called multiple times.
-  if (IsShowingContextMenu())
+  if (IsShowingContextMenu()) {
     return;
+  }
 
   // Notify the host before showing the context menu.
   web_contents()->SetShowingContextMenu(true);
@@ -254,11 +263,13 @@ void CefMenuManager::MenuWillShow(CefRefPtr<CefMenuModelImpl> source) {
 
 void CefMenuManager::MenuClosed(CefRefPtr<CefMenuModelImpl> source) {
   // May be called for sub-menus as well.
-  if (source.get() != model_.get())
+  if (source.get() != model_.get()) {
     return;
+  }
 
-  if (!web_contents())
+  if (!web_contents()) {
     return;
+  }
 
   DCHECK(IsShowingContextMenu());
 
@@ -278,8 +289,9 @@ void CefMenuManager::MenuClosed(CefRefPtr<CefMenuModelImpl> source) {
 
 bool CefMenuManager::FormatLabel(CefRefPtr<CefMenuModelImpl> source,
                                  std::u16string& label) {
-  if (!runner_)
+  if (!runner_) {
     return false;
+  }
   return runner_->FormatLabel(label);
 }
 
@@ -287,8 +299,9 @@ void CefMenuManager::ExecuteCommandCallback(int command_id,
                                             cef_event_flags_t event_flags) {
   DCHECK(IsShowingContextMenu());
   DCHECK(custom_menu_callback_);
-  if (command_id != kInvalidCommandId)
+  if (command_id != kInvalidCommandId) {
     ExecuteCommand(model_, command_id, event_flags);
+  }
   MenuClosed(model_);
   custom_menu_callback_ = nullptr;
 }
@@ -320,20 +333,27 @@ void CefMenuManager::CreateDefaultModel() {
     model_->AddItem(MENU_ID_SELECT_ALL,
                     GetLabel(IDS_CONTENT_CONTEXT_SELECTALL));
 
-    if (!(params_.edit_flags & CM_EDITFLAG_CAN_UNDO))
+    if (!(params_.edit_flags & CM_EDITFLAG_CAN_UNDO)) {
       model_->SetEnabled(MENU_ID_UNDO, false);
-    if (!(params_.edit_flags & CM_EDITFLAG_CAN_REDO))
+    }
+    if (!(params_.edit_flags & CM_EDITFLAG_CAN_REDO)) {
       model_->SetEnabled(MENU_ID_REDO, false);
-    if (!(params_.edit_flags & CM_EDITFLAG_CAN_CUT))
+    }
+    if (!(params_.edit_flags & CM_EDITFLAG_CAN_CUT)) {
       model_->SetEnabled(MENU_ID_CUT, false);
-    if (!(params_.edit_flags & CM_EDITFLAG_CAN_COPY))
+    }
+    if (!(params_.edit_flags & CM_EDITFLAG_CAN_COPY)) {
       model_->SetEnabled(MENU_ID_COPY, false);
-    if (!(params_.edit_flags & CM_EDITFLAG_CAN_PASTE))
+    }
+    if (!(params_.edit_flags & CM_EDITFLAG_CAN_PASTE)) {
       model_->SetEnabled(MENU_ID_PASTE, false);
-    if (!(params_.edit_flags & CM_EDITFLAG_CAN_DELETE))
+    }
+    if (!(params_.edit_flags & CM_EDITFLAG_CAN_DELETE)) {
       model_->SetEnabled(MENU_ID_DELETE, false);
-    if (!(params_.edit_flags & CM_EDITFLAG_CAN_SELECT_ALL))
+    }
+    if (!(params_.edit_flags & CM_EDITFLAG_CAN_SELECT_ALL)) {
       model_->SetEnabled(MENU_ID_SELECT_ALL, false);
+    }
 
     if (!params_.misspelled_word.empty()) {
       // Always add a separator before the list of dictionary suggestions or
@@ -374,10 +394,12 @@ void CefMenuManager::CreateDefaultModel() {
     model_->AddItem(MENU_ID_VIEW_SOURCE,
                     GetLabel(IDS_CONTENT_CONTEXT_VIEWPAGESOURCE));
 
-    if (!browser_->CanGoBack())
+    if (!browser_->CanGoBack()) {
       model_->SetEnabled(MENU_ID_BACK, false);
-    if (!browser_->CanGoForward())
+    }
+    if (!browser_->CanGoForward()) {
       model_->SetEnabled(MENU_ID_FORWARD, false);
+    }
   }
 }
 
@@ -467,16 +489,18 @@ void CefMenuManager::ExecuteDefaultCommand(int command_id) {
 
 bool CefMenuManager::IsCustomContextMenuCommand(int command_id) {
   // Verify that the command ID is in the correct range.
-  if (command_id < MENU_ID_CUSTOM_FIRST || command_id > MENU_ID_CUSTOM_LAST)
+  if (command_id < MENU_ID_CUSTOM_FIRST || command_id > MENU_ID_CUSTOM_LAST) {
     return false;
+  }
 
   command_id -= MENU_ID_CUSTOM_FIRST;
 
   // Verify that the specific command ID was passed from the renderer process.
   if (!params_.custom_items.empty()) {
     for (size_t i = 0; i < params_.custom_items.size(); ++i) {
-      if (static_cast<int>(params_.custom_items[i]->action) == command_id)
+      if (static_cast<int>(params_.custom_items[i]->action) == command_id) {
         return true;
+      }
     }
   }
   return false;
diff --git a/libcef/browser/menu_model_impl.cc b/libcef/browser/menu_model_impl.cc
index 1be1f36e4..004721a8b 100644
--- a/libcef/browser/menu_model_impl.cc
+++ b/libcef/browser/menu_model_impl.cc
@@ -86,12 +86,15 @@ class CefSimpleMenuModel : public ui::MenuModel {
     if (impl_->GetAcceleratorAt(index, key_code, shift_pressed, ctrl_pressed,
                                 alt_pressed)) {
       int modifiers = 0;
-      if (shift_pressed)
+      if (shift_pressed) {
         modifiers |= ui::EF_SHIFT_DOWN;
-      if (ctrl_pressed)
+      }
+      if (ctrl_pressed) {
         modifiers |= ui::EF_CONTROL_DOWN;
-      if (alt_pressed)
+      }
+      if (alt_pressed) {
         modifiers |= ui::EF_ALT_DOWN;
+      }
 
       *accelerator =
           ui::Accelerator(static_cast<ui::KeyboardCode>(key_code), modifiers);
@@ -132,8 +135,9 @@ class CefSimpleMenuModel : public ui::MenuModel {
 
   MenuModel* GetSubmenuModelAt(size_t index) const override {
     CefRefPtr<CefMenuModel> submenu = impl_->GetSubMenuAt(index);
-    if (submenu.get())
+    if (submenu.get()) {
       return static_cast<CefMenuModelImpl*>(submenu.get())->model();
+    }
     return nullptr;
   }
 
@@ -193,8 +197,9 @@ CefRefPtr<CefMenuModel> CefMenuModel::CreateMenuModel(
     CefRefPtr<CefMenuModelDelegate> delegate) {
   CEF_REQUIRE_UIT_RETURN(nullptr);
   DCHECK(delegate);
-  if (!delegate)
+  if (!delegate) {
     return nullptr;
+  }
 
   CefRefPtr<CefMenuModelImpl> menu_model =
       new CefMenuModelImpl(nullptr, delegate, false);
@@ -250,29 +255,33 @@ CefMenuModelImpl::CefMenuModelImpl(
 CefMenuModelImpl::~CefMenuModelImpl() {}
 
 bool CefMenuModelImpl::IsSubMenu() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
   return is_submenu_;
 }
 
 bool CefMenuModelImpl::Clear() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   items_.clear();
   return true;
 }
 
 size_t CefMenuModelImpl::GetCount() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return 0;
+  }
 
   return items_.size();
 }
 
 bool CefMenuModelImpl::AddSeparator() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   AppendItem(
       Item(MENUITEMTYPE_SEPARATOR, kSeparatorId, CefString(), kInvalidGroupId));
@@ -280,16 +289,18 @@ bool CefMenuModelImpl::AddSeparator() {
 }
 
 bool CefMenuModelImpl::AddItem(int command_id, const CefString& label) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   AppendItem(Item(MENUITEMTYPE_COMMAND, command_id, label, kInvalidGroupId));
   return true;
 }
 
 bool CefMenuModelImpl::AddCheckItem(int command_id, const CefString& label) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   AppendItem(Item(MENUITEMTYPE_CHECK, command_id, label, kInvalidGroupId));
   return true;
@@ -298,8 +309,9 @@ bool CefMenuModelImpl::AddCheckItem(int command_id, const CefString& label) {
 bool CefMenuModelImpl::AddRadioItem(int command_id,
                                     const CefString& label,
                                     int group_id) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   AppendItem(Item(MENUITEMTYPE_RADIO, command_id, label, group_id));
   return true;
@@ -307,8 +319,9 @@ bool CefMenuModelImpl::AddRadioItem(int command_id,
 
 CefRefPtr<CefMenuModel> CefMenuModelImpl::AddSubMenu(int command_id,
                                                      const CefString& label) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return nullptr;
+  }
 
   Item item(MENUITEMTYPE_SUBMENU, command_id, label, kInvalidGroupId);
   item.submenu_ = new CefMenuModelImpl(delegate_, menu_model_delegate_, true);
@@ -317,8 +330,9 @@ CefRefPtr<CefMenuModel> CefMenuModelImpl::AddSubMenu(int command_id,
 }
 
 bool CefMenuModelImpl::InsertSeparatorAt(size_t index) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   InsertItemAt(
       Item(MENUITEMTYPE_SEPARATOR, kSeparatorId, CefString(), kInvalidGroupId),
@@ -329,8 +343,9 @@ bool CefMenuModelImpl::InsertSeparatorAt(size_t index) {
 bool CefMenuModelImpl::InsertItemAt(size_t index,
                                     int command_id,
                                     const CefString& label) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   InsertItemAt(Item(MENUITEMTYPE_COMMAND, command_id, label, kInvalidGroupId),
                index);
@@ -340,8 +355,9 @@ bool CefMenuModelImpl::InsertItemAt(size_t index,
 bool CefMenuModelImpl::InsertCheckItemAt(size_t index,
                                          int command_id,
                                          const CefString& label) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   InsertItemAt(Item(MENUITEMTYPE_CHECK, command_id, label, kInvalidGroupId),
                index);
@@ -352,8 +368,9 @@ bool CefMenuModelImpl::InsertRadioItemAt(size_t index,
                                          int command_id,
                                          const CefString& label,
                                          int group_id) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   InsertItemAt(Item(MENUITEMTYPE_RADIO, command_id, label, group_id), index);
   return true;
@@ -363,8 +380,9 @@ CefRefPtr<CefMenuModel> CefMenuModelImpl::InsertSubMenuAt(
     size_t index,
     int command_id,
     const CefString& label) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return nullptr;
+  }
 
   Item item(MENUITEMTYPE_SUBMENU, command_id, label, kInvalidGroupId);
   item.submenu_ = new CefMenuModelImpl(delegate_, menu_model_delegate_, true);
@@ -377,8 +395,9 @@ bool CefMenuModelImpl::Remove(int command_id) {
 }
 
 bool CefMenuModelImpl::RemoveAt(size_t index) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   if (index < items_.size()) {
     items_.erase(items_.begin() + index);
@@ -388,8 +407,9 @@ bool CefMenuModelImpl::RemoveAt(size_t index) {
 }
 
 int CefMenuModelImpl::GetIndexOf(int command_id) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return kInvalidIndex;
+  }
 
   for (ItemVector::iterator i = items_.begin(); i != items_.end(); ++i) {
     if ((*i).command_id_ == command_id) {
@@ -400,17 +420,20 @@ int CefMenuModelImpl::GetIndexOf(int command_id) {
 }
 
 int CefMenuModelImpl::GetCommandIdAt(size_t index) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return kInvalidCommandId;
+  }
 
-  if (index < items_.size())
+  if (index < items_.size()) {
     return items_[index].command_id_;
+  }
   return kInvalidCommandId;
 }
 
 bool CefMenuModelImpl::SetCommandIdAt(size_t index, int command_id) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   if (index < items_.size()) {
     items_[index].command_id_ = command_id;
@@ -424,11 +447,13 @@ CefString CefMenuModelImpl::GetLabel(int command_id) {
 }
 
 CefString CefMenuModelImpl::GetLabelAt(size_t index) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return CefString();
+  }
 
-  if (index < items_.size())
+  if (index < items_.size()) {
     return items_[index].label_;
+  }
   return CefString();
 }
 
@@ -437,8 +462,9 @@ bool CefMenuModelImpl::SetLabel(int command_id, const CefString& label) {
 }
 
 bool CefMenuModelImpl::SetLabelAt(size_t index, const CefString& label) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   if (index < items_.size()) {
     items_[index].label_ = label;
@@ -452,11 +478,13 @@ CefMenuModelImpl::MenuItemType CefMenuModelImpl::GetType(int command_id) {
 }
 
 CefMenuModelImpl::MenuItemType CefMenuModelImpl::GetTypeAt(size_t index) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return MENUITEMTYPE_NONE;
+  }
 
-  if (index < items_.size())
+  if (index < items_.size()) {
     return items_[index].type_;
+  }
   return MENUITEMTYPE_NONE;
 }
 
@@ -465,11 +493,13 @@ int CefMenuModelImpl::GetGroupId(int command_id) {
 }
 
 int CefMenuModelImpl::GetGroupIdAt(size_t index) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return kInvalidGroupId;
+  }
 
-  if (index < items_.size())
+  if (index < items_.size()) {
     return items_[index].group_id_;
+  }
   return kInvalidGroupId;
 }
 
@@ -478,8 +508,9 @@ bool CefMenuModelImpl::SetGroupId(int command_id, int group_id) {
 }
 
 bool CefMenuModelImpl::SetGroupIdAt(size_t index, int group_id) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   if (index < items_.size()) {
     items_[index].group_id_ = group_id;
@@ -493,11 +524,13 @@ CefRefPtr<CefMenuModel> CefMenuModelImpl::GetSubMenu(int command_id) {
 }
 
 CefRefPtr<CefMenuModel> CefMenuModelImpl::GetSubMenuAt(size_t index) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return nullptr;
+  }
 
-  if (index < items_.size())
+  if (index < items_.size()) {
     return items_[index].submenu_.get();
+  }
   return nullptr;
 }
 
@@ -506,11 +539,13 @@ bool CefMenuModelImpl::IsVisible(int command_id) {
 }
 
 bool CefMenuModelImpl::IsVisibleAt(size_t index) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
-  if (index < items_.size())
+  if (index < items_.size()) {
     return items_[index].visible_;
+  }
   return false;
 }
 
@@ -519,8 +554,9 @@ bool CefMenuModelImpl::SetVisible(int command_id, bool visible) {
 }
 
 bool CefMenuModelImpl::SetVisibleAt(size_t index, bool visible) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   if (index < items_.size()) {
     items_[index].visible_ = visible;
@@ -534,11 +570,13 @@ bool CefMenuModelImpl::IsEnabled(int command_id) {
 }
 
 bool CefMenuModelImpl::IsEnabledAt(size_t index) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
-  if (index < items_.size())
+  if (index < items_.size()) {
     return items_[index].enabled_;
+  }
   return false;
 }
 
@@ -547,8 +585,9 @@ bool CefMenuModelImpl::SetEnabled(int command_id, bool enabled) {
 }
 
 bool CefMenuModelImpl::SetEnabledAt(size_t index, bool enabled) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   if (index < items_.size()) {
     items_[index].enabled_ = enabled;
@@ -562,11 +601,13 @@ bool CefMenuModelImpl::IsChecked(int command_id) {
 }
 
 bool CefMenuModelImpl::IsCheckedAt(size_t index) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
-  if (index < items_.size())
+  if (index < items_.size()) {
     return items_[index].checked_;
+  }
   return false;
 }
 
@@ -575,8 +616,9 @@ bool CefMenuModelImpl::SetChecked(int command_id, bool checked) {
 }
 
 bool CefMenuModelImpl::SetCheckedAt(size_t index, bool checked) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   if (index < items_.size()) {
     items_[index].checked_ = checked;
@@ -590,11 +632,13 @@ bool CefMenuModelImpl::HasAccelerator(int command_id) {
 }
 
 bool CefMenuModelImpl::HasAcceleratorAt(size_t index) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
-  if (index < items_.size())
+  if (index < items_.size()) {
     return items_[index].has_accelerator_;
+  }
   return false;
 }
 
@@ -612,8 +656,9 @@ bool CefMenuModelImpl::SetAcceleratorAt(size_t index,
                                         bool shift_pressed,
                                         bool ctrl_pressed,
                                         bool alt_pressed) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   if (index < items_.size()) {
     Item& item = items_[index];
@@ -632,8 +677,9 @@ bool CefMenuModelImpl::RemoveAccelerator(int command_id) {
 }
 
 bool CefMenuModelImpl::RemoveAcceleratorAt(size_t index) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   if (index < items_.size()) {
     Item& item = items_[index];
@@ -663,8 +709,9 @@ bool CefMenuModelImpl::GetAcceleratorAt(size_t index,
                                         bool& shift_pressed,
                                         bool& ctrl_pressed,
                                         bool& alt_pressed) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   if (index < items_.size()) {
     const Item& item = items_[index];
@@ -688,11 +735,13 @@ bool CefMenuModelImpl::SetColor(int command_id,
 bool CefMenuModelImpl::SetColorAt(int index,
                                   cef_menu_color_type_t color_type,
                                   cef_color_t color) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
-  if (color_type < 0 || color_type >= CEF_MENU_COLOR_COUNT)
+  if (color_type < 0 || color_type >= CEF_MENU_COLOR_COUNT) {
     return false;
+  }
 
   if (index == kDefaultIndex) {
     default_colors_[color_type] = color;
@@ -717,11 +766,13 @@ bool CefMenuModelImpl::GetColor(int command_id,
 bool CefMenuModelImpl::GetColorAt(int index,
                                   cef_menu_color_type_t color_type,
                                   cef_color_t& color) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
-  if (color_type < 0 || color_type >= CEF_MENU_COLOR_COUNT)
+  if (color_type < 0 || color_type >= CEF_MENU_COLOR_COUNT) {
     return false;
+  }
 
   if (index == kDefaultIndex) {
     color = default_colors_[color_type];
@@ -742,8 +793,9 @@ bool CefMenuModelImpl::SetFontList(int command_id, const CefString& font_list) {
 }
 
 bool CefMenuModelImpl::SetFontListAt(int index, const CefString& font_list) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   if (index == kDefaultIndex) {
     if (font_list.empty()) {
@@ -770,19 +822,23 @@ bool CefMenuModelImpl::SetFontListAt(int index, const CefString& font_list) {
 
 void CefMenuModelImpl::ActivatedAt(size_t index,
                                    cef_event_flags_t event_flags) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return;
+  }
 
   const int command_id = GetCommandIdAt(index);
-  if (delegate_)
+  if (delegate_) {
     delegate_->ExecuteCommand(this, command_id, event_flags);
-  if (menu_model_delegate_)
+  }
+  if (menu_model_delegate_) {
     menu_model_delegate_->ExecuteCommand(this, command_id, event_flags);
+  }
 }
 
 void CefMenuModelImpl::MouseOutsideMenu(const gfx::Point& screen_point) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return;
+  }
 
   // Allow the callstack to unwind before notifying the delegate since it may
   // result in the menu being destroyed.
@@ -792,8 +848,9 @@ void CefMenuModelImpl::MouseOutsideMenu(const gfx::Point& screen_point) {
 }
 
 void CefMenuModelImpl::UnhandledOpenSubmenu(bool is_rtl) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return;
+  }
 
   // Allow the callstack to unwind before notifying the delegate since it may
   // result in the menu being destroyed.
@@ -803,8 +860,9 @@ void CefMenuModelImpl::UnhandledOpenSubmenu(bool is_rtl) {
 }
 
 void CefMenuModelImpl::UnhandledCloseSubmenu(bool is_rtl) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return;
+  }
 
   // Allow the callstack to unwind before notifying the delegate since it may
   // result in the menu being destroyed.
@@ -865,21 +923,26 @@ bool CefMenuModelImpl::GetBackgroundColor(size_t index,
 }
 
 void CefMenuModelImpl::MenuWillShow() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return;
+  }
 
-  if (delegate_)
+  if (delegate_) {
     delegate_->MenuWillShow(this);
-  if (menu_model_delegate_)
+  }
+  if (menu_model_delegate_) {
     menu_model_delegate_->MenuWillShow(this);
+  }
 }
 
 void CefMenuModelImpl::MenuWillClose() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return;
+  }
 
-  if (!auto_notify_menu_closed_)
+  if (!auto_notify_menu_closed_) {
     return;
+  }
 
   // Due to how menus work on the different platforms, ActivatedAt will be
   // called after this.  It's more convenient for the delegate to be called
@@ -890,12 +953,14 @@ void CefMenuModelImpl::MenuWillClose() {
 
 std::u16string CefMenuModelImpl::GetFormattedLabelAt(size_t index) {
   std::u16string label = GetLabelAt(index).ToString16();
-  if (delegate_)
+  if (delegate_) {
     delegate_->FormatLabel(this, label);
+  }
   if (menu_model_delegate_) {
     CefString new_label = label;
-    if (menu_model_delegate_->FormatLabel(this, new_label))
+    if (menu_model_delegate_->FormatLabel(this, new_label)) {
       label = new_label;
+    }
   }
   return label;
 }
@@ -903,26 +968,31 @@ std::u16string CefMenuModelImpl::GetFormattedLabelAt(size_t index) {
 const gfx::FontList* CefMenuModelImpl::GetLabelFontListAt(size_t index) const {
   if (index < items_.size()) {
     const Item& item = items_[index];
-    if (item.has_font_list_)
+    if (item.has_font_list_) {
       return &item.font_list_;
+    }
   }
 
-  if (has_default_font_list_)
+  if (has_default_font_list_) {
     return &default_font_list_;
+  }
   return nullptr;
 }
 
 bool CefMenuModelImpl::VerifyRefCount() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
-  if (!HasOneRef())
+  if (!HasOneRef()) {
     return false;
+  }
 
   for (ItemVector::iterator i = items_.begin(); i != items_.end(); ++i) {
     if ((*i).submenu_.get()) {
-      if (!(*i).submenu_->VerifyRefCount())
+      if (!(*i).submenu_->VerifyRefCount()) {
         return false;
+      }
     }
   }
 
@@ -949,15 +1019,17 @@ void CefMenuModelImpl::AddMenuItem(
     case blink::mojom::CustomContextMenuItemType::kSubMenu: {
       CefRefPtr<CefMenuModelImpl> sub_menu = static_cast<CefMenuModelImpl*>(
           AddSubMenu(command_id, menu_item.label).get());
-      for (size_t i = 0; i < menu_item.submenu.size(); ++i)
+      for (size_t i = 0; i < menu_item.submenu.size(); ++i) {
         sub_menu->AddMenuItem(*menu_item.submenu[i]);
+      }
       break;
     }
   }
 
   if (!menu_item.enabled &&
-      menu_item.type != blink::mojom::CustomContextMenuItemType::kSeparator)
+      menu_item.type != blink::mojom::CustomContextMenuItemType::kSeparator) {
     SetEnabled(command_id, false);
+  }
 
   if (menu_item.checked &&
       (menu_item.type ==
@@ -979,8 +1051,9 @@ void CefMenuModelImpl::AppendItem(const Item& item) {
 
 void CefMenuModelImpl::InsertItemAt(const Item& item, size_t index) {
   // Sanitize the index.
-  if (index > items_.size())
+  if (index > items_.size()) {
     index = items_.size();
+  }
 
   ValidateItem(item);
   items_.insert(items_.begin() + index, item);
@@ -997,8 +1070,9 @@ void CefMenuModelImpl::ValidateItem(const Item& item) {
 }
 
 void CefMenuModelImpl::OnMouseOutsideMenu(const gfx::Point& screen_point) {
-  if (delegate_)
+  if (delegate_) {
     delegate_->MouseOutsideMenu(this, screen_point);
+  }
   if (menu_model_delegate_) {
     menu_model_delegate_->MouseOutsideMenu(
         this, CefPoint(screen_point.x(), screen_point.y()));
@@ -1006,24 +1080,30 @@ void CefMenuModelImpl::OnMouseOutsideMenu(const gfx::Point& screen_point) {
 }
 
 void CefMenuModelImpl::OnUnhandledOpenSubmenu(bool is_rtl) {
-  if (delegate_)
+  if (delegate_) {
     delegate_->UnhandledOpenSubmenu(this, is_rtl);
-  if (menu_model_delegate_)
+  }
+  if (menu_model_delegate_) {
     menu_model_delegate_->UnhandledOpenSubmenu(this, is_rtl);
+  }
 }
 
 void CefMenuModelImpl::OnUnhandledCloseSubmenu(bool is_rtl) {
-  if (delegate_)
+  if (delegate_) {
     delegate_->UnhandledCloseSubmenu(this, is_rtl);
-  if (menu_model_delegate_)
+  }
+  if (menu_model_delegate_) {
     menu_model_delegate_->UnhandledCloseSubmenu(this, is_rtl);
+  }
 }
 
 void CefMenuModelImpl::OnMenuClosed() {
-  if (delegate_)
+  if (delegate_) {
     delegate_->MenuClosed(this);
-  if (menu_model_delegate_)
+  }
+  if (menu_model_delegate_) {
     menu_model_delegate_->MenuClosed(this);
+  }
 }
 
 bool CefMenuModelImpl::VerifyContext() {
diff --git a/libcef/browser/native/browser_platform_delegate_native_aura.cc b/libcef/browser/native/browser_platform_delegate_native_aura.cc
index 468f49b00..33266899d 100644
--- a/libcef/browser/native/browser_platform_delegate_native_aura.cc
+++ b/libcef/browser/native/browser_platform_delegate_native_aura.cc
@@ -23,8 +23,9 @@ CefBrowserPlatformDelegateNativeAura::CefBrowserPlatformDelegateNativeAura(
 void CefBrowserPlatformDelegateNativeAura::SendKeyEvent(
     const CefKeyEvent& event) {
   auto view = GetHostView();
-  if (!view)
+  if (!view) {
     return;
+  }
 
   ui::KeyEvent ui_event = TranslateUiKeyEvent(event);
   view->OnKeyEvent(&ui_event);
@@ -36,8 +37,9 @@ void CefBrowserPlatformDelegateNativeAura::SendMouseClickEvent(
     bool mouseUp,
     int clickCount) {
   auto view = GetHostView();
-  if (!view)
+  if (!view) {
     return;
+  }
 
   ui::MouseEvent ui_event =
       TranslateUiClickEvent(event, type, mouseUp, clickCount);
@@ -48,8 +50,9 @@ void CefBrowserPlatformDelegateNativeAura::SendMouseMoveEvent(
     const CefMouseEvent& event,
     bool mouseLeave) {
   auto view = GetHostView();
-  if (!view)
+  if (!view) {
     return;
+  }
 
   ui::MouseEvent ui_event = TranslateUiMoveEvent(event, mouseLeave);
   view->OnMouseEvent(&ui_event);
@@ -60,8 +63,9 @@ void CefBrowserPlatformDelegateNativeAura::SendMouseWheelEvent(
     int deltaX,
     int deltaY) {
   auto view = GetHostView();
-  if (!view)
+  if (!view) {
     return;
+  }
 
   ui::MouseWheelEvent ui_event = TranslateUiWheelEvent(event, deltaX, deltaY);
   view->OnMouseEvent(&ui_event);
@@ -80,11 +84,13 @@ CefBrowserPlatformDelegateNativeAura::CreateMenuRunner() {
 gfx::Point CefBrowserPlatformDelegateNativeAura::GetScreenPoint(
     const gfx::Point& view,
     bool want_dip_coords) const {
-  if (windowless_handler_)
+  if (windowless_handler_) {
     return windowless_handler_->GetParentScreenPoint(view, want_dip_coords);
+  }
 
-  if (!window_widget_)
+  if (!window_widget_) {
     return view;
+  }
 
   gfx::Point screen_pt(view);
   if (!view_util::ConvertPointToScreen(
@@ -220,30 +226,42 @@ int CefBrowserPlatformDelegateNativeAura::TranslateUiEventModifiers(
     uint32 cef_modifiers) {
   int result = 0;
   // Set modifiers based on key state.
-  if (cef_modifiers & EVENTFLAG_CAPS_LOCK_ON)
+  if (cef_modifiers & EVENTFLAG_CAPS_LOCK_ON) {
     result |= ui::EF_CAPS_LOCK_ON;
-  if (cef_modifiers & EVENTFLAG_SHIFT_DOWN)
+  }
+  if (cef_modifiers & EVENTFLAG_SHIFT_DOWN) {
     result |= ui::EF_SHIFT_DOWN;
-  if (cef_modifiers & EVENTFLAG_CONTROL_DOWN)
+  }
+  if (cef_modifiers & EVENTFLAG_CONTROL_DOWN) {
     result |= ui::EF_CONTROL_DOWN;
-  if (cef_modifiers & EVENTFLAG_ALT_DOWN)
+  }
+  if (cef_modifiers & EVENTFLAG_ALT_DOWN) {
     result |= ui::EF_ALT_DOWN;
-  if (cef_modifiers & EVENTFLAG_LEFT_MOUSE_BUTTON)
+  }
+  if (cef_modifiers & EVENTFLAG_LEFT_MOUSE_BUTTON) {
     result |= ui::EF_LEFT_MOUSE_BUTTON;
-  if (cef_modifiers & EVENTFLAG_MIDDLE_MOUSE_BUTTON)
+  }
+  if (cef_modifiers & EVENTFLAG_MIDDLE_MOUSE_BUTTON) {
     result |= ui::EF_MIDDLE_MOUSE_BUTTON;
-  if (cef_modifiers & EVENTFLAG_RIGHT_MOUSE_BUTTON)
+  }
+  if (cef_modifiers & EVENTFLAG_RIGHT_MOUSE_BUTTON) {
     result |= ui::EF_RIGHT_MOUSE_BUTTON;
-  if (cef_modifiers & EVENTFLAG_COMMAND_DOWN)
+  }
+  if (cef_modifiers & EVENTFLAG_COMMAND_DOWN) {
     result |= ui::EF_COMMAND_DOWN;
-  if (cef_modifiers & EVENTFLAG_NUM_LOCK_ON)
+  }
+  if (cef_modifiers & EVENTFLAG_NUM_LOCK_ON) {
     result |= ui::EF_NUM_LOCK_ON;
-  if (cef_modifiers & EVENTFLAG_IS_KEY_PAD)
+  }
+  if (cef_modifiers & EVENTFLAG_IS_KEY_PAD) {
     result |= ui::EF_IS_EXTENDED_KEY;
-  if (cef_modifiers & EVENTFLAG_ALTGR_DOWN)
+  }
+  if (cef_modifiers & EVENTFLAG_ALTGR_DOWN) {
     result |= ui::EF_ALTGR_DOWN;
-  if (cef_modifiers & EVENTFLAG_IS_REPEAT)
+  }
+  if (cef_modifiers & EVENTFLAG_IS_REPEAT) {
     result |= ui::EF_IS_REPEAT;
+  }
   return result;
 }
 
@@ -251,19 +269,21 @@ int CefBrowserPlatformDelegateNativeAura::TranslateUiEventModifiers(
 int CefBrowserPlatformDelegateNativeAura::TranslateUiChangedButtonFlags(
     uint32 cef_modifiers) {
   int result = 0;
-  if (cef_modifiers & EVENTFLAG_LEFT_MOUSE_BUTTON)
+  if (cef_modifiers & EVENTFLAG_LEFT_MOUSE_BUTTON) {
     result |= ui::EF_LEFT_MOUSE_BUTTON;
-  else if (cef_modifiers & EVENTFLAG_MIDDLE_MOUSE_BUTTON)
+  } else if (cef_modifiers & EVENTFLAG_MIDDLE_MOUSE_BUTTON) {
     result |= ui::EF_MIDDLE_MOUSE_BUTTON;
-  else if (cef_modifiers & EVENTFLAG_RIGHT_MOUSE_BUTTON)
+  } else if (cef_modifiers & EVENTFLAG_RIGHT_MOUSE_BUTTON) {
     result |= ui::EF_RIGHT_MOUSE_BUTTON;
+  }
   return result;
 }
 
 content::RenderWidgetHostViewAura*
 CefBrowserPlatformDelegateNativeAura::GetHostView() const {
-  if (!web_contents_)
+  if (!web_contents_) {
     return nullptr;
+  }
   return static_cast<content::RenderWidgetHostViewAura*>(
       web_contents_->GetRenderWidgetHostView());
 }
diff --git a/libcef/browser/native/browser_platform_delegate_native_linux.cc b/libcef/browser/native/browser_platform_delegate_native_linux.cc
index 5972a3134..a17e0017c 100644
--- a/libcef/browser/native/browser_platform_delegate_native_linux.cc
+++ b/libcef/browser/native/browser_platform_delegate_native_linux.cc
@@ -45,10 +45,12 @@ void CefBrowserPlatformDelegateNativeLinux::BrowserDestroyed(
 bool CefBrowserPlatformDelegateNativeLinux::CreateHostWindow() {
   DCHECK(!window_widget_);
 
-  if (window_info_.bounds.width == 0)
+  if (window_info_.bounds.width == 0) {
     window_info_.bounds.width = 800;
-  if (window_info_.bounds.height == 0)
+  }
+  if (window_info_.bounds.height == 0) {
     window_info_.bounds.height = 600;
+  }
 
   gfx::Rect rect(window_info_.bounds.x, window_info_.bounds.y,
                  window_info_.bounds.width, window_info_.bounds.height);
@@ -114,15 +116,17 @@ bool CefBrowserPlatformDelegateNativeLinux::CreateHostWindow() {
 
 void CefBrowserPlatformDelegateNativeLinux::CloseHostWindow() {
 #if BUILDFLAG(OZONE_PLATFORM_X11)
-  if (window_x11_)
+  if (window_x11_) {
     window_x11_->Close();
+  }
 #endif
 }
 
 CefWindowHandle CefBrowserPlatformDelegateNativeLinux::GetHostWindowHandle()
     const {
-  if (windowless_handler_)
+  if (windowless_handler_) {
     return windowless_handler_->GetParentWindowHandle();
+  }
   return window_info_.window;
 }
 
@@ -131,8 +135,9 @@ views::Widget* CefBrowserPlatformDelegateNativeLinux::GetWindowWidget() const {
 }
 
 void CefBrowserPlatformDelegateNativeLinux::SetFocus(bool setFocus) {
-  if (!setFocus)
+  if (!setFocus) {
     return;
+  }
 
   if (web_contents_) {
     // Give logical focus to the RenderWidgetHostViewAura in the views
@@ -154,16 +159,19 @@ void CefBrowserPlatformDelegateNativeLinux::NotifyMoveOrResizeStarted() {
   // Call the parent method to dismiss any existing popups.
   CefBrowserPlatformDelegateNativeAura::NotifyMoveOrResizeStarted();
 
-  if (!web_contents_)
+  if (!web_contents_) {
     return;
+  }
 
 #if BUILDFLAG(OZONE_PLATFORM_X11)
-  if (!window_x11_)
+  if (!window_x11_) {
     return;
+  }
 
   views::DesktopWindowTreeHostLinux* tree_host = window_x11_->GetHost();
-  if (!tree_host)
+  if (!tree_host) {
     return;
+  }
 
   // Explicitly set the screen bounds so that WindowTreeHost::*Screen()
   // methods return the correct results.
@@ -191,12 +199,14 @@ void CefBrowserPlatformDelegateNativeLinux::ViewText(const std::string& text) {
   char buff[] = "/tmp/CEFSourceXXXXXX";
   int fd = mkstemp(buff);
 
-  if (fd == -1)
+  if (fd == -1) {
     return;
+  }
 
   FILE* srcOutput = fdopen(fd, "w+");
-  if (!srcOutput)
+  if (!srcOutput) {
     return;
+  }
 
   if (fputs(text.c_str(), srcOutput) < 0) {
     fclose(srcOutput);
@@ -207,8 +217,9 @@ void CefBrowserPlatformDelegateNativeLinux::ViewText(const std::string& text) {
 
   std::string newName(buff);
   newName.append(".txt");
-  if (rename(buff, newName.c_str()) != 0)
+  if (rename(buff, newName.c_str()) != 0) {
     return;
+  }
 
   std::string openCommand("xdg-open ");
   openCommand += newName;
diff --git a/libcef/browser/native/browser_platform_delegate_native_mac.mm b/libcef/browser/native/browser_platform_delegate_native_mac.mm
index d8af708d2..92d93c0df 100644
--- a/libcef/browser/native/browser_platform_delegate_native_mac.mm
+++ b/libcef/browser/native/browser_platform_delegate_native_mac.mm
@@ -111,9 +111,9 @@ namespace {
 
 NSTimeInterval currentEventTimestamp() {
   NSEvent* currentEvent = [NSApp currentEvent];
-  if (currentEvent)
+  if (currentEvent) {
     return [currentEvent timestamp];
-  else {
+  } else {
     // FIXME(API): In case there is no current event, the timestamp could be
     // obtained by getting the time since the application started. This involves
     // taking some more static functions from Chromium code.
@@ -125,18 +125,24 @@ NSTimeInterval currentEventTimestamp() {
 
 NSUInteger NativeModifiers(int cef_modifiers) {
   NSUInteger native_modifiers = 0;
-  if (cef_modifiers & EVENTFLAG_SHIFT_DOWN)
+  if (cef_modifiers & EVENTFLAG_SHIFT_DOWN) {
     native_modifiers |= NSEventModifierFlagShift;
-  if (cef_modifiers & EVENTFLAG_CONTROL_DOWN)
+  }
+  if (cef_modifiers & EVENTFLAG_CONTROL_DOWN) {
     native_modifiers |= NSEventModifierFlagControl;
-  if (cef_modifiers & EVENTFLAG_ALT_DOWN)
+  }
+  if (cef_modifiers & EVENTFLAG_ALT_DOWN) {
     native_modifiers |= NSEventModifierFlagOption;
-  if (cef_modifiers & EVENTFLAG_COMMAND_DOWN)
+  }
+  if (cef_modifiers & EVENTFLAG_COMMAND_DOWN) {
     native_modifiers |= NSEventModifierFlagCommand;
-  if (cef_modifiers & EVENTFLAG_CAPS_LOCK_ON)
+  }
+  if (cef_modifiers & EVENTFLAG_CAPS_LOCK_ON) {
     native_modifiers |= NSEventModifierFlagCapsLock;
-  if (cef_modifiers & EVENTFLAG_NUM_LOCK_ON)
+  }
+  if (cef_modifiers & EVENTFLAG_NUM_LOCK_ON) {
     native_modifiers |= NSEventModifierFlagNumericPad;
+  }
 
   return native_modifiers;
 }
@@ -342,16 +348,18 @@ void CefBrowserPlatformDelegateNativeMac::CloseHostWindow() {
 
 CefWindowHandle CefBrowserPlatformDelegateNativeMac::GetHostWindowHandle()
     const {
-  if (windowless_handler_)
+  if (windowless_handler_) {
     return windowless_handler_->GetParentWindowHandle();
+  }
   return window_info_.view;
 }
 
 void CefBrowserPlatformDelegateNativeMac::SendKeyEvent(
     const CefKeyEvent& event) {
   auto view = GetHostView();
-  if (!view)
+  if (!view) {
     return;
+  }
 
   content::NativeWebKeyboardEvent web_event = TranslateWebKeyEvent(event);
   view->ForwardKeyboardEvent(web_event, ui::LatencyInfo());
@@ -363,8 +371,9 @@ void CefBrowserPlatformDelegateNativeMac::SendMouseClickEvent(
     bool mouseUp,
     int clickCount) {
   auto view = GetHostView();
-  if (!view)
+  if (!view) {
     return;
+  }
 
   blink::WebMouseEvent web_event =
       TranslateWebClickEvent(event, type, mouseUp, clickCount);
@@ -375,8 +384,9 @@ void CefBrowserPlatformDelegateNativeMac::SendMouseMoveEvent(
     const CefMouseEvent& event,
     bool mouseLeave) {
   auto view = GetHostView();
-  if (!view)
+  if (!view) {
     return;
+  }
 
   blink::WebMouseEvent web_event = TranslateWebMoveEvent(event, mouseLeave);
   view->RouteOrProcessMouseEvent(web_event);
@@ -387,8 +397,9 @@ void CefBrowserPlatformDelegateNativeMac::SendMouseWheelEvent(
     int deltaX,
     int deltaY) {
   auto view = GetHostView();
-  if (!view)
+  if (!view) {
     return;
+  }
 
   blink::WebMouseWheelEvent web_event =
       TranslateWebWheelEvent(event, deltaX, deltaY);
@@ -418,8 +429,9 @@ gfx::Point CefBrowserPlatformDelegateNativeMac::GetScreenPoint(
     const gfx::Point& view,
     bool want_dip_coords) const {
   // Mac always operates in DIP coordinates so |want_dip_coords| is ignored.
-  if (windowless_handler_)
+  if (windowless_handler_) {
     return windowless_handler_->GetParentScreenPoint(view, want_dip_coords);
+  }
 
   NSView* nsview = CAST_CEF_WINDOW_HANDLE_TO_NSVIEW(window_info_.parent_view);
   if (nsview) {
@@ -442,8 +454,9 @@ void CefBrowserPlatformDelegateNativeMac::ViewText(const std::string& text) {
 bool CefBrowserPlatformDelegateNativeMac::HandleKeyboardEvent(
     const content::NativeWebKeyboardEvent& event) {
   // Give the top level menu equivalents a chance to handle the event.
-  if ([event.os_event type] == NSEventTypeKeyDown)
+  if ([event.os_event type] == NSEventTypeKeyDown) {
     return [[NSApp mainMenu] performKeyEquivalent:event.os_event];
+  }
   return false;
 }
 
@@ -517,8 +530,9 @@ CefBrowserPlatformDelegateNativeMac::TranslateWebKeyEvent(
                               keyCode:key_event.native_key_code];
 
   result = content::NativeWebKeyboardEvent(synthetic_event);
-  if (key_event.type == KEYEVENT_CHAR)
+  if (key_event.type == KEYEVENT_CHAR) {
     result.SetType(blink::WebInputEvent::Type::kChar);
+  }
 
   result.is_system_key = key_event.is_system_key;
 
@@ -567,14 +581,15 @@ blink::WebMouseEvent CefBrowserPlatformDelegateNativeMac::TranslateWebMoveEvent(
 
   if (!mouseLeave) {
     result.SetType(blink::WebInputEvent::Type::kMouseMove);
-    if (mouse_event.modifiers & EVENTFLAG_LEFT_MOUSE_BUTTON)
+    if (mouse_event.modifiers & EVENTFLAG_LEFT_MOUSE_BUTTON) {
       result.button = blink::WebMouseEvent::Button::kLeft;
-    else if (mouse_event.modifiers & EVENTFLAG_MIDDLE_MOUSE_BUTTON)
+    } else if (mouse_event.modifiers & EVENTFLAG_MIDDLE_MOUSE_BUTTON) {
       result.button = blink::WebMouseEvent::Button::kMiddle;
-    else if (mouse_event.modifiers & EVENTFLAG_RIGHT_MOUSE_BUTTON)
+    } else if (mouse_event.modifiers & EVENTFLAG_RIGHT_MOUSE_BUTTON) {
       result.button = blink::WebMouseEvent::Button::kRight;
-    else
+    } else {
       result.button = blink::WebMouseEvent::Button::kNoButton;
+    }
   } else {
     result.SetType(blink::WebInputEvent::Type::kMouseLeave);
     result.button = blink::WebMouseEvent::Button::kNoButton;
@@ -602,14 +617,15 @@ CefBrowserPlatformDelegateNativeMac::TranslateWebWheelEvent(
   result.wheel_ticks_y = deltaY / scrollbarPixelsPerCocoaTick;
   result.delta_units = ui::ScrollGranularity::kScrollByPrecisePixel;
 
-  if (mouse_event.modifiers & EVENTFLAG_LEFT_MOUSE_BUTTON)
+  if (mouse_event.modifiers & EVENTFLAG_LEFT_MOUSE_BUTTON) {
     result.button = blink::WebMouseEvent::Button::kLeft;
-  else if (mouse_event.modifiers & EVENTFLAG_MIDDLE_MOUSE_BUTTON)
+  } else if (mouse_event.modifiers & EVENTFLAG_MIDDLE_MOUSE_BUTTON) {
     result.button = blink::WebMouseEvent::Button::kMiddle;
-  else if (mouse_event.modifiers & EVENTFLAG_RIGHT_MOUSE_BUTTON)
+  } else if (mouse_event.modifiers & EVENTFLAG_RIGHT_MOUSE_BUTTON) {
     result.button = blink::WebMouseEvent::Button::kRight;
-  else
+  } else {
     result.button = blink::WebMouseEvent::Button::kNoButton;
+  }
 
   return result;
 }
@@ -637,8 +653,9 @@ void CefBrowserPlatformDelegateNativeMac::TranslateWebMouseEvent(
 
 content::RenderWidgetHostViewMac*
 CefBrowserPlatformDelegateNativeMac::GetHostView() const {
-  if (!web_contents_)
+  if (!web_contents_) {
     return nullptr;
+  }
   return static_cast<content::RenderWidgetHostViewMac*>(
       web_contents_->GetRenderWidgetHostView());
 }
diff --git a/libcef/browser/native/browser_platform_delegate_native_win.cc b/libcef/browser/native/browser_platform_delegate_native_win.cc
index 729c73e15..44c3586b5 100644
--- a/libcef/browser/native/browser_platform_delegate_native_win.cc
+++ b/libcef/browser/native/browser_platform_delegate_native_win.cc
@@ -46,8 +46,9 @@ void WriteTempFileAndView(const std::string& data) {
   CEF_REQUIRE_BLOCKING();
 
   base::FilePath tmp_file;
-  if (!base::CreateTemporaryFile(&tmp_file))
+  if (!base::CreateTemporaryFile(&tmp_file)) {
     return;
+  }
 
   // The shell command will look at the file extension to identify the correct
   // program to open.
@@ -82,8 +83,9 @@ bool HasExternalHandler(const std::string& scheme) {
 void ExecuteExternalProtocol(const GURL& url) {
   CEF_REQUIRE_BLOCKING();
 
-  if (!HasExternalHandler(url.scheme()))
+  if (!HasExternalHandler(url.scheme())) {
     return;
+  }
 
   // Quote the input scheme to be sure that the command does not have
   // parameters unexpected by the external program. This url should already
@@ -99,8 +101,9 @@ void ExecuteExternalProtocol(const GURL& url) {
   //
   // It may be possible to increase this. https://crbug.com/727909
   const size_t kMaxUrlLength = 2048;
-  if (escaped_url.length() > kMaxUrlLength)
+  if (escaped_url.length() > kMaxUrlLength) {
     return;
+  }
 
   // Specify %windir%\system32 as the CWD so that any new proc spawned does not
   // inherit this proc's CWD. Without this, uninstalls may be broken by a
@@ -239,8 +242,9 @@ bool CefBrowserPlatformDelegateNativeWin::CreateHostWindow() {
   // It's possible for CreateWindowEx to fail if the parent window was
   // destroyed between the call to CreateBrowser and the above one.
   DCHECK(window_info_.window);
-  if (!window_info_.window)
+  if (!window_info_.window) {
     return false;
+  }
 
   host_window_created_ = true;
 
@@ -257,8 +261,9 @@ bool CefBrowserPlatformDelegateNativeWin::CreateHostWindow() {
       return reinterpret_cast<EnableChildWindowDpiMessagePtr>(GetProcAddress(
           GetModuleHandle(L"user32.dll"), "EnableChildWindowDpiMessage"));
     }();
-    if (enable_child_window_dpi_message_func)
+    if (enable_child_window_dpi_message_func) {
       enable_child_window_dpi_message_func(window_info_.window, TRUE);
+    }
   }
 
   DCHECK(!window_widget_);
@@ -317,8 +322,9 @@ void CefBrowserPlatformDelegateNativeWin::CloseHostWindow() {
 
 CefWindowHandle CefBrowserPlatformDelegateNativeWin::GetHostWindowHandle()
     const {
-  if (windowless_handler_)
+  if (windowless_handler_) {
     return windowless_handler_->GetParentWindowHandle();
+  }
   return window_info_.window;
 }
 
@@ -327,8 +333,9 @@ views::Widget* CefBrowserPlatformDelegateNativeWin::GetWindowWidget() const {
 }
 
 void CefBrowserPlatformDelegateNativeWin::SetFocus(bool setFocus) {
-  if (!setFocus)
+  if (!setFocus) {
     return;
+  }
 
   if (window_widget_) {
     // Give native focus to the DesktopWindowTreeHostWin ("Chrome_WidgetWin_0")
@@ -397,8 +404,9 @@ void CefBrowserPlatformDelegateNativeWin::NotifyMoveOrResizeStarted() {
   // Call the parent method to dismiss any existing popups.
   CefBrowserPlatformDelegateNativeAura::NotifyMoveOrResizeStarted();
 
-  if (!window_widget_)
+  if (!window_widget_) {
     return;
+  }
 
   // Notify DesktopWindowTreeHostWin of move events so that screen rectangle
   // information is communicated to the renderer process and popups are
@@ -444,8 +452,9 @@ bool CefBrowserPlatformDelegateNativeWin::HandleKeyboardEvent(
     MSG msg = {};
 
     msg.hwnd = GetHostWindowHandle();
-    if (!msg.hwnd)
+    if (!msg.hwnd) {
       return false;
+    }
 
     switch (event.GetType()) {
       case blink::WebInputEvent::Type::kRawKeyDown:
@@ -467,8 +476,9 @@ bool CefBrowserPlatformDelegateNativeWin::HandleKeyboardEvent(
     UINT scan_code = ::MapVirtualKeyW(event.windows_key_code, MAPVK_VK_TO_VSC);
     msg.lParam = (scan_code << 16) |  // key scan code
                  1;                   // key repeat count
-    if (event.GetModifiers() & content::NativeWebKeyboardEvent::kAltKey)
+    if (event.GetModifiers() & content::NativeWebKeyboardEvent::kAltKey) {
       msg.lParam |= (1 << 29);
+    }
 
     return !DefWindowProc(msg.hwnd, msg.message, msg.wParam, msg.lParam);
   }
@@ -481,8 +491,9 @@ void CefBrowserPlatformDelegate::HandleExternalProtocol(const GURL& url) {
 
 CefEventHandle CefBrowserPlatformDelegateNativeWin::GetEventHandle(
     const content::NativeWebKeyboardEvent& event) const {
-  if (!event.os_event)
+  if (!event.os_event) {
     return NULL;
+  }
   return ChromeToWindowsType(
       const_cast<CHROME_MSG*>(&event.os_event->native_event()));
 }
@@ -545,8 +556,9 @@ gfx::Vector2d CefBrowserPlatformDelegateNativeWin::GetUiWheelEventOffset(
 // static
 void CefBrowserPlatformDelegateNativeWin::RegisterWindowClass() {
   static bool registered = false;
-  if (registered)
+  if (registered) {
     return;
+  }
 
   // Register the window class
   WNDCLASSEX wcex = {
@@ -651,16 +663,18 @@ LRESULT CALLBACK CefBrowserPlatformDelegateNativeWin::WndProc(HWND hwnd,
 
     case WM_MOVING:
     case WM_MOVE:
-      if (browser)
+      if (browser) {
         browser->NotifyMoveOrResizeStarted();
+      }
       return 0;
 
     case WM_SETFOCUS:
       // Selecting "Close window" from the task bar menu may send a focus
       // notification even though the window is currently disabled (e.g. while
       // a modal JS dialog is displayed).
-      if (browser && ::IsWindowEnabled(hwnd))
+      if (browser && ::IsWindowEnabled(hwnd)) {
         browser->SetFocus(true);
+      }
       return 0;
 
     case WM_ERASEBKGND:
diff --git a/libcef/browser/native/cursor_util.cc b/libcef/browser/native/cursor_util.cc
index 8a92a68ea..42ab5f6c1 100644
--- a/libcef/browser/native/cursor_util.cc
+++ b/libcef/browser/native/cursor_util.cc
@@ -50,14 +50,18 @@ display::Display::Rotation OrientationAngleToRotation(
   // angle. The former is the physical display rotation while the later is the
   // rotation required by the content to be shown properly on the screen, in
   // other words, relative to the physical display.
-  if (orientation_angle == 0)
+  if (orientation_angle == 0) {
     return display::Display::ROTATE_0;
-  if (orientation_angle == 90)
+  }
+  if (orientation_angle == 90) {
     return display::Display::ROTATE_270;
-  if (orientation_angle == 180)
+  }
+  if (orientation_angle == 180) {
     return display::Display::ROTATE_180;
-  if (orientation_angle == 270)
+  }
+  if (orientation_angle == 270) {
     return display::Display::ROTATE_90;
+  }
   NOTREACHED();
   return display::Display::ROTATE_0;
 }
@@ -69,11 +73,13 @@ display::Display::Rotation OrientationAngleToRotation(
 bool OnCursorChange(CefRefPtr<CefBrowser> browser,
                     const ui::Cursor& ui_cursor) {
   auto client = browser->GetHost()->GetClient();
-  if (!client)
+  if (!client) {
     return false;
+  }
   auto handler = client->GetDisplayHandler();
-  if (!handler)
+  if (!handler) {
     return false;
+  }
 
   const cef_cursor_type_t cursor_type =
       static_cast<cef_cursor_type_t>(ui_cursor.type());
diff --git a/libcef/browser/native/javascript_dialog_runner_mac.mm b/libcef/browser/native/javascript_dialog_runner_mac.mm
index cead4fb2d..00335276f 100644
--- a/libcef/browser/native/javascript_dialog_runner_mac.mm
+++ b/libcef/browser/native/javascript_dialog_runner_mac.mm
@@ -38,8 +38,9 @@
 
 - (id)initHelperWithCallback:
     (CefJavaScriptDialogRunner::DialogClosedCallback)callback {
-  if (self = [super init])
+  if (self = [super init]) {
     callback_ = std::move(callback);
+  }
 
   return self;
 }
@@ -62,13 +63,15 @@
 - (void)alertDidEnd:(NSAlert*)alert
          returnCode:(int)returnCode
         contextInfo:(void*)contextInfo {
-  if (returnCode == NSModalResponseStop)
+  if (returnCode == NSModalResponseStop) {
     return;
+  }
 
   bool success = returnCode == NSAlertFirstButtonReturn;
   std::u16string input;
-  if (textField_)
+  if (textField_) {
     input = base::SysNSStringToUTF16([textField_ stringValue]);
+  }
 
   std::move(callback_).Run(success, input);
 }
@@ -130,8 +133,9 @@ void CefJavaScriptDialogRunnerMac::Run(
 
   const std::u16string& display_url =
       url_formatter::FormatUrlForSecurityDisplay(origin_url);
-  if (!display_url.empty())
+  if (!display_url.empty()) {
     label += u" - " + display_url;
+  }
 
   [alert setMessageText:base::SysUTF16ToNSString(label)];
 
@@ -156,8 +160,9 @@ void CefJavaScriptDialogRunnerMac::Run(
                       contextInfo:this];
 #pragma clang diagnostic pop
 
-  if ([alert accessoryView])
+  if ([alert accessoryView]) {
     [[alert window] makeFirstResponder:[alert accessoryView]];
+  }
 }
 
 void CefJavaScriptDialogRunnerMac::Handle(
diff --git a/libcef/browser/native/menu_runner_mac.mm b/libcef/browser/native/menu_runner_mac.mm
index 66963fbdd..55b7c78d5 100644
--- a/libcef/browser/native/menu_runner_mac.mm
+++ b/libcef/browser/native/menu_runner_mac.mm
@@ -45,8 +45,9 @@ bool CefMenuRunnerMac::RunContextMenu(
   // Show the menu. Blocks until the menu is dismissed.
   if (browser->IsWindowless()) {
     // Don't show the menu unless a native window handle exists.
-    if (!browser->GetWindowHandle())
+    if (!browser->GetWindowHandle()) {
       return false;
+    }
 
     const gfx::Point& screen_point = browser->GetScreenPoint(
         gfx::Point(params.x, params.y), /*want_dip_coords=*/true);
@@ -85,6 +86,7 @@ bool CefMenuRunnerMac::RunContextMenu(
 }
 
 void CefMenuRunnerMac::CancelContextMenu() {
-  if (menu_controller_.get())
+  if (menu_controller_.get()) {
     [menu_controller_ cancel];
+  }
 }
diff --git a/libcef/browser/native/menu_runner_views_aura.cc b/libcef/browser/native/menu_runner_views_aura.cc
index bf8dd8294..2b0accc4f 100644
--- a/libcef/browser/native/menu_runner_views_aura.cc
+++ b/libcef/browser/native/menu_runner_views_aura.cc
@@ -41,8 +41,9 @@ bool CefMenuRunnerViewsAura::RunContextMenu(
 }
 
 void CefMenuRunnerViewsAura::CancelContextMenu() {
-  if (menu_)
+  if (menu_) {
     menu_->Cancel();
+  }
 }
 
 bool CefMenuRunnerViewsAura::FormatLabel(std::u16string& label) {
diff --git a/libcef/browser/native/window_delegate_view.cc b/libcef/browser/native/window_delegate_view.cc
index 5670cf473..c562cfce7 100644
--- a/libcef/browser/native/window_delegate_view.cc
+++ b/libcef/browser/native/window_delegate_view.cc
@@ -74,12 +74,14 @@ void CefWindowDelegateView::InitContent() {
 
 void CefWindowDelegateView::ViewHierarchyChanged(
     const views::ViewHierarchyChangedDetails& details) {
-  if (details.is_add && details.child == this)
+  if (details.is_add && details.child == this) {
     InitContent();
+  }
 }
 
 void CefWindowDelegateView::OnBoundsChanged(const gfx::Rect& previous_bounds) {
   views::WidgetDelegateView::OnBoundsChanged(previous_bounds);
-  if (!on_bounds_changed_.is_null())
+  if (!on_bounds_changed_.is_null()) {
     on_bounds_changed_.Run();
+  }
 }
diff --git a/libcef/browser/native/window_x11.cc b/libcef/browser/native/window_x11.cc
index 620bd3b9c..7de600660 100644
--- a/libcef/browser/native/window_x11.cc
+++ b/libcef/browser/native/window_x11.cc
@@ -46,16 +46,18 @@ bool PropertyExists(x11::Window window, x11::Atom property) {
 // Deleted from ui/base/x/x11_util.h in https://crrev.com/62fc260067.
 bool IsWindowVisible(x11::Window window) {
   auto response = x11::Connection::Get()->GetWindowAttributes({window}).Sync();
-  if (!response || response->map_state != x11::MapState::Viewable)
+  if (!response || response->map_state != x11::MapState::Viewable) {
     return false;
+  }
 
   // Minimized windows are not visible.
   std::vector<x11::Atom> wm_states;
   if (x11::GetArrayProperty(window, x11::GetAtom("_NET_WM_STATE"),
                             &wm_states)) {
     x11::Atom hidden_atom = x11::GetAtom("_NET_WM_STATE_HIDDEN");
-    if (base::Contains(wm_states, hidden_atom))
+    if (base::Contains(wm_states, hidden_atom)) {
       return false;
+    }
   }
 
   // Do not check _NET_CURRENT_DESKTOP/_NET_WM_DESKTOP since some
@@ -79,8 +81,9 @@ x11::Window FindToplevelParent(x11::Window window) {
 
   do {
     auto query_tree = x11::Connection::Get()->QueryTree({window}).Sync();
-    if (!query_tree)
+    if (!query_tree) {
       break;
+    }
 
     top_level_window = window;
     if (!PropertyExists(query_tree->parent, x11::GetAtom(kNetWMPid)) ||
@@ -97,8 +100,9 @@ x11::Window FindToplevelParent(x11::Window window) {
 }  // namespace
 
 CEF_EXPORT XDisplay* cef_get_xdisplay() {
-  if (!CEF_CURRENTLY_ON(CEF_UIT))
+  if (!CEF_CURRENTLY_ON(CEF_UIT)) {
     return nullptr;
+  }
   return x11::Connection::Get()->GetXlibDisplay();
 }
 
@@ -111,8 +115,9 @@ CefWindowX11::CefWindowX11(CefRefPtr<CefBrowserHostBase> browser,
       parent_xwindow_(parent_xwindow),
       bounds_(bounds),
       weak_ptr_factory_(this) {
-  if (parent_xwindow_ == x11::Window::None)
+  if (parent_xwindow_ == x11::Window::None) {
     parent_xwindow_ = ui::GetX11RootWindow();
+  }
 
   x11::VisualId visual;
   uint8_t depth;
@@ -184,8 +189,9 @@ CefWindowX11::~CefWindowX11() {
 }
 
 void CefWindowX11::Close() {
-  if (xwindow_ == x11::Window::None)
+  if (xwindow_ == x11::Window::None) {
     return;
+  }
 
   ui::SendClientMessage(
       xwindow_, xwindow_, x11::GetAtom(kWMProtocols),
@@ -194,13 +200,15 @@ void CefWindowX11::Close() {
       x11::EventMask::NoEvent);
 
   auto host = GetHost();
-  if (host)
+  if (host) {
     host->Close();
+  }
 }
 
 void CefWindowX11::Show() {
-  if (xwindow_ == x11::Window::None)
+  if (xwindow_ == x11::Window::None) {
     return;
+  }
 
   if (!window_mapped_) {
     // Before we map the window, set size hints. Otherwise, some window managers
@@ -245,8 +253,9 @@ void CefWindowX11::Show() {
 }
 
 void CefWindowX11::Hide() {
-  if (xwindow_ == x11::Window::None)
+  if (xwindow_ == x11::Window::None) {
     return;
+  }
 
   if (window_mapped_) {
     ui::WithdrawWindow(xwindow_);
@@ -255,8 +264,9 @@ void CefWindowX11::Hide() {
 }
 
 void CefWindowX11::Focus() {
-  if (xwindow_ == x11::Window::None || !window_mapped_)
+  if (xwindow_ == x11::Window::None || !window_mapped_) {
     return;
+  }
 
   x11::Window focus_target = xwindow_;
 
@@ -277,8 +287,9 @@ void CefWindowX11::Focus() {
 }
 
 void CefWindowX11::SetBounds(const gfx::Rect& bounds) {
-  if (xwindow_ == x11::Window::None)
+  if (xwindow_ == x11::Window::None) {
     return;
+  }
 
   x11::ConfigureWindowRequest req{.window = xwindow_};
 
@@ -338,30 +349,35 @@ uint32_t CefWindowX11::DispatchEvent(const ui::PlatformEvent& event) {
 }
 
 void CefWindowX11::OnEvent(const x11::Event& event) {
-  if (event.window() != xwindow_)
+  if (event.window() != xwindow_) {
     return;
+  }
   ProcessXEvent(event);
 }
 
 void CefWindowX11::ContinueFocus() {
-  if (!focus_pending_)
+  if (!focus_pending_) {
     return;
-  if (browser_.get())
+  }
+  if (browser_.get()) {
     browser_->SetFocus(true);
+  }
   focus_pending_ = false;
 }
 
 bool CefWindowX11::TopLevelAlwaysOnTop() const {
   auto toplevel_window = FindToplevelParent(xwindow_);
-  if (toplevel_window == x11::Window::None)
+  if (toplevel_window == x11::Window::None) {
     return false;
+  }
 
   std::vector<x11::Atom> wm_states;
   if (x11::GetArrayProperty(toplevel_window, x11::GetAtom(kNetWMState),
                             &wm_states)) {
     x11::Atom keep_above_atom = x11::GetAtom(kNetWMStateKeepAbove);
-    if (base::Contains(wm_states, keep_above_atom))
+    if (base::Contains(wm_states, keep_above_atom)) {
       return true;
+    }
   }
   return false;
 }
@@ -434,8 +450,9 @@ void CefWindowX11::ProcessXEvent(const x11::Event& event) {
       // Cancel the pending focus change if some other window has gained focus
       // while waiting for the async task to run. Otherwise we can get stuck in
       // a focus change loop.
-      if (focus_pending_)
+      if (focus_pending_) {
         focus_pending_ = false;
+      }
     }
   } else if (auto* property = event.As<x11::PropertyNotifyEvent>()) {
     const auto& wm_state_atom = x11::GetAtom(kNetWMState);
diff --git a/libcef/browser/net/chrome_scheme_handler.cc b/libcef/browser/net/chrome_scheme_handler.cc
index 8e46963b5..2a8f02833 100644
--- a/libcef/browser/net/chrome_scheme_handler.cc
+++ b/libcef/browser/net/chrome_scheme_handler.cc
@@ -157,8 +157,9 @@ void GetAllowedHosts(std::vector<std::string>* hosts) {
 bool IsUnlistedHost(const std::string& host) {
   for (size_t i = 0; i < sizeof(kUnlistedHosts) / sizeof(kUnlistedHosts[0]);
        ++i) {
-    if (host == kUnlistedHosts[i])
+    if (host == kUnlistedHosts[i]) {
       return true;
+    }
   }
   return false;
 }
@@ -166,8 +167,9 @@ bool IsUnlistedHost(const std::string& host) {
 // Returns true if a host is WebUI and should be allowed to load.
 bool IsAllowedWebUIHost(const std::string& host) {
   // Chrome runtime allows all WebUI hosts.
-  if (cef::IsChromeRuntimeEnabled())
+  if (cef::IsChromeRuntimeEnabled()) {
     return true;
+  }
 
   // Explicitly whitelisted WebUI hosts.
   for (size_t i = 0;
@@ -216,8 +218,10 @@ std::string GetCommandLine() {
   std::string command_line = "";
   using ArgvList = std::vector<std::string>;
   const ArgvList& argv = base::CommandLine::ForCurrentProcess()->argv();
-  for (ArgvList::const_iterator iter = argv.begin(); iter != argv.end(); iter++)
+  for (ArgvList::const_iterator iter = argv.begin(); iter != argv.end();
+       iter++) {
     command_line += " " + *iter;
+  }
   // TODO(viettrungluu): |command_line| could really have any encoding, whereas
   // below we assumes it's UTF-8.
   return command_line;
@@ -226,8 +230,9 @@ std::string GetCommandLine() {
 
 std::string GetModulePath() {
   base::FilePath path;
-  if (base::PathService::Get(base::FILE_MODULE, &path))
+  if (base::PathService::Get(base::FILE_MODULE, &path)) {
     return CefString(path.value());
+  }
   return std::string();
 }
 
@@ -414,8 +419,9 @@ bool OnWebUIHostsUI(std::string* mime_type, std::string* output) {
   std::sort(list.begin(), list.end());
 
   for (size_t i = 0U; i < list.size(); ++i) {
-    if (IsUnlistedHost(list[i]))
+    if (IsUnlistedHost(list[i])) {
       continue;
+    }
 
     html += "<li><a href=\"chrome://" + list[i] + "\">chrome://" + list[i] +
             "</a></li>\n";
@@ -533,16 +539,18 @@ class CefWebUIControllerFactory : public content::WebUIControllerFactory {
       return false;
     }
 
-    if (IsAllowedWebUIHost(url.host()))
+    if (IsAllowedWebUIHost(url.host())) {
       return true;
+    }
 
     return false;
   }
 
   // Returns true if WebUI is allowed to make network requests.
   static bool IsWebUIAllowedToMakeNetworkRequests(const url::Origin& origin) {
-    if (!AllowWebUIForURL(origin.GetURL()))
+    if (!AllowWebUIForURL(origin.GetURL())) {
       return false;
+    }
 
     if (ChromeWebUIControllerFactory::IsWebUIAllowedToMakeNetworkRequests(
             origin)) {
@@ -556,8 +564,9 @@ class CefWebUIControllerFactory : public content::WebUIControllerFactory {
       content::WebUI* web_ui,
       const GURL& url) override {
     std::unique_ptr<content::WebUIController> controller;
-    if (!AllowWebUIForURL(url))
+    if (!AllowWebUIForURL(url)) {
       return controller;
+    }
 
     // Set up the chrome://theme/ source. These URLs are referenced from many
     // places (WebUI and chrome://resources which live in //ui). WebUI code
@@ -577,8 +586,9 @@ class CefWebUIControllerFactory : public content::WebUIControllerFactory {
     controller = content::WebUIConfigMap::GetInstance()
                      .controller_factory()
                      ->CreateWebUIControllerForURL(web_ui, url);
-    if (controller)
+    if (controller) {
       return controller;
+    }
 
     return ChromeWebUIControllerFactory::GetInstance()
         ->CreateWebUIControllerForURL(web_ui, url);
@@ -587,8 +597,9 @@ class CefWebUIControllerFactory : public content::WebUIControllerFactory {
   content::WebUI::TypeID GetWebUIType(content::BrowserContext* browser_context,
                                       const GURL& url) override {
     content::WebUI::TypeID type = content::WebUI::kNoWebUI;
-    if (!AllowWebUIForURL(url))
+    if (!AllowWebUIForURL(url)) {
       return type;
+    }
 
     const auto host_id = GetChromeHostId(url.host());
     if (host_id != CHROME_UNKNOWN) {
@@ -598,21 +609,24 @@ class CefWebUIControllerFactory : public content::WebUIControllerFactory {
     type = content::WebUIConfigMap::GetInstance()
                .controller_factory()
                ->GetWebUIType(browser_context, url);
-    if (type != content::WebUI::kNoWebUI)
+    if (type != content::WebUI::kNoWebUI) {
       return type;
+    }
 
     type = ChromeWebUIControllerFactory::GetInstance()->GetWebUIType(
         browser_context, url);
-    if (type != content::WebUI::kNoWebUI)
+    if (type != content::WebUI::kNoWebUI) {
       return type;
+    }
 
     return content::WebUI::kNoWebUI;
   }
 
   bool UseWebUIForURL(content::BrowserContext* browser_context,
                       const GURL& url) override {
-    if (!AllowWebUIForURL(url))
+    if (!AllowWebUIForURL(url)) {
       return false;
+    }
 
     const auto host_id = GetChromeHostId(url.host());
     if (host_id != CHROME_UNKNOWN) {
@@ -657,8 +671,9 @@ class CefWebUIControllerFactory : public content::WebUIControllerFactory {
 
   // Handles rewriting Web UI URLs.
   static bool HandleWebUI(GURL* url, content::BrowserContext* browser_context) {
-    if (!GetInstance()->UseWebUIForURL(browser_context, *url))
+    if (!GetInstance()->UseWebUIForURL(browser_context, *url)) {
       return false;
+    }
 
     return true;
   }
diff --git a/libcef/browser/net/devtools_scheme_handler.cc b/libcef/browser/net/devtools_scheme_handler.cc
index 62fa22566..97f120427 100644
--- a/libcef/browser/net/devtools_scheme_handler.cc
+++ b/libcef/browser/net/devtools_scheme_handler.cc
@@ -29,8 +29,9 @@ class Delegate : public InternalHandlerDelegate {
                  Action* action) override {
     GURL url = GURL(request->GetURL().ToString());
     std::string path = url.path();
-    if (path.length() > 0)
+    if (path.length() > 0) {
       path = path.substr(1);
+    }
 
     action->bytes =
         content::DevToolsFrontendHost::GetFrontendResourceBytes(path);
diff --git a/libcef/browser/net/internal_scheme_handler.cc b/libcef/browser/net/internal_scheme_handler.cc
index e69807d88..707147b27 100644
--- a/libcef/browser/net/internal_scheme_handler.cc
+++ b/libcef/browser/net/internal_scheme_handler.cc
@@ -36,16 +36,19 @@ std::string GetMimeType(const std::string& filename) {
 
   std::string mime_type;
   const base::FilePath& file_path = FilePathFromASCII(filename);
-  if (net::GetMimeTypeFromFile(file_path, &mime_type))
+  if (net::GetMimeTypeFromFile(file_path, &mime_type)) {
     return mime_type;
+  }
 
   // Check for newer extensions used by internal resources but not yet
   // recognized by the mime type detector.
   const std::string& extension = CefString(file_path.FinalExtension());
-  if (extension == ".md")
+  if (extension == ".md") {
     return "text/markdown";
-  if (extension == ".woff2")
+  }
+  if (extension == ".woff2") {
     return "application/font-woff2";
+  }
 
   NOTREACHED() << "No known mime type for file: " << filename.c_str();
   return "text/plain";
@@ -161,11 +164,13 @@ class InternalHandlerFactory : public CefSchemeHandlerFactory {
 
     InternalHandlerDelegate::Action action;
     if (delegate_->OnRequest(browser, request, &action)) {
-      if (!action.redirect_url.is_empty() && action.redirect_url.is_valid())
+      if (!action.redirect_url.is_empty() && action.redirect_url.is_valid()) {
         return new RedirectHandler(action.redirect_url);
+      }
 
-      if (action.mime_type.empty())
+      if (action.mime_type.empty()) {
         action.mime_type = GetMimeType(url.path());
+      }
 
       if (!action.bytes && action.resource_id >= 0) {
         std::string str =
diff --git a/libcef/browser/net/scheme_handler.cc b/libcef/browser/net/scheme_handler.cc
index 9686e53fa..347d21fa5 100644
--- a/libcef/browser/net/scheme_handler.cc
+++ b/libcef/browser/net/scheme_handler.cc
@@ -16,8 +16,9 @@
 namespace scheme {
 
 void RegisterInternalHandlers(CefIOThreadState* iothread_state) {
-  if (!cef::IsAlloyRuntimeEnabled())
+  if (!cef::IsAlloyRuntimeEnabled()) {
     return;
+  }
 
   scheme::RegisterChromeDevToolsHandler(iothread_state);
 }
diff --git a/libcef/browser/net_service/browser_urlrequest_impl.cc b/libcef/browser/net_service/browser_urlrequest_impl.cc
index ae90398f8..a8247e273 100644
--- a/libcef/browser/net_service/browser_urlrequest_impl.cc
+++ b/libcef/browser/net_service/browser_urlrequest_impl.cc
@@ -77,8 +77,9 @@ class RequestManager {
   }
 
   void Remove(int32_t request_id) {
-    if (request_id > kInitialRequestID)
+    if (request_id > kInitialRequestID) {
       return;
+    }
 
     base::AutoLock lock_scope(lock_);
     RequestMap::iterator it = map_.find(request_id);
@@ -87,8 +88,9 @@ class RequestManager {
   }
 
   absl::optional<CefBrowserURLRequest::RequestInfo> Get(int32_t request_id) {
-    if (request_id > kInitialRequestID)
+    if (request_id > kInitialRequestID) {
       return absl::nullopt;
+    }
 
     base::AutoLock lock_scope(lock_);
     RequestMap::const_iterator it = map_.find(request_id);
@@ -143,8 +145,9 @@ class CefBrowserURLRequest::Context
     DCHECK(CalledOnValidThread());
 
     const GURL& url = GURL(request_->GetURL().ToString());
-    if (!url.is_valid())
+    if (!url.is_valid()) {
       return false;
+    }
 
     if (!request_context_) {
       request_context_ = CefRequestContext::GetGlobalContext();
@@ -166,8 +169,9 @@ class CefBrowserURLRequest::Context
     DCHECK(CalledOnValidThread());
 
     // The request may already be complete or canceled.
-    if (!url_request_)
+    if (!url_request_) {
       return;
+    }
 
     DCHECK_EQ(status_, UR_IO_PENDING);
     status_ = UR_CANCELED;
@@ -252,8 +256,9 @@ class CefBrowserURLRequest::Context
     DCHECK(CalledOnValidThread());
 
     // The request may have been canceled.
-    if (!url_request_)
+    if (!url_request_) {
       return;
+    }
 
     if (!loader_factory_getter) {
       // Cancel the request immediately.
@@ -463,8 +468,9 @@ class CefBrowserURLRequest::Context
     DCHECK_EQ(status_, UR_IO_PENDING);
 
     upload_data_size_ = total;
-    if (position == total)
+    if (position == total) {
       got_upload_progress_complete_ = true;
+    }
 
     client_->OnUploadProgress(url_request_.get(), position, total);
   }
@@ -511,8 +517,9 @@ class CefBrowserURLRequest::Context
     DCHECK(CalledOnValidThread());
 
     // The request may already be complete or canceled.
-    if (!url_request_)
+    if (!url_request_) {
       return;
+    }
 
     // Status will be UR_IO_PENDING if we're called when the request is complete
     // (via SimpleURLLoaderStreamConsumer or OnHeadersOnly). We can only call
@@ -528,8 +535,9 @@ class CefBrowserURLRequest::Context
       response_was_cached_ = loader_->LoadedFromCache();
     }
 
-    if (success)
+    if (success) {
       NotifyUploadProgressIfNecessary();
+    }
 
     client_->OnRequestComplete(url_request_.get());
 
@@ -629,50 +637,58 @@ CefBrowserURLRequest::CefBrowserURLRequest(
 CefBrowserURLRequest::~CefBrowserURLRequest() {}
 
 bool CefBrowserURLRequest::Start() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
   return context_->Start();
 }
 
 CefRefPtr<CefRequest> CefBrowserURLRequest::GetRequest() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return nullptr;
+  }
   return context_->request();
 }
 
 CefRefPtr<CefURLRequestClient> CefBrowserURLRequest::GetClient() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return nullptr;
+  }
   return context_->client();
 }
 
 CefURLRequest::Status CefBrowserURLRequest::GetRequestStatus() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return UR_UNKNOWN;
+  }
   return context_->status();
 }
 
 CefURLRequest::ErrorCode CefBrowserURLRequest::GetRequestError() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return ERR_NONE;
+  }
   return context_->response()->GetError();
 }
 
 CefRefPtr<CefResponse> CefBrowserURLRequest::GetResponse() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return nullptr;
+  }
   return context_->response();
 }
 
 bool CefBrowserURLRequest::ResponseWasCached() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
   return context_->response_was_cached();
 }
 
 void CefBrowserURLRequest::Cancel() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return;
+  }
   return context_->Cancel();
 }
 
diff --git a/libcef/browser/net_service/cookie_helper.cc b/libcef/browser/net_service/cookie_helper.cc
index 2c954b473..ef2416f48 100644
--- a/libcef/browser/net_service/cookie_helper.cc
+++ b/libcef/browser/net_service/cookie_helper.cc
@@ -94,8 +94,9 @@ void ContinueWithLoadedCookies(const AllowCookieCallback& allow_cookie_callback,
   for (const auto& status : cookies) {
     bool allow = false;
     allow_cookie_callback.Run(status.cookie, &allow);
-    if (allow)
+    if (allow) {
       allowed_cookies.push_back(status.cookie);
+    }
   }
   std::move(done_callback).Run(cookies.size(), std::move(allowed_cookies));
 }
@@ -213,16 +214,18 @@ void SaveCookiesOnUIThread(
 bool IsCookieableScheme(
     const GURL& url,
     const absl::optional<std::vector<std::string>>& cookieable_schemes) {
-  if (!url.has_scheme())
+  if (!url.has_scheme()) {
     return false;
+  }
 
   if (cookieable_schemes) {
     // The client has explicitly registered the full set of schemes that should
     // be supported.
     const auto url_scheme = url.scheme_piece();
     for (auto scheme : *cookieable_schemes) {
-      if (url_scheme == scheme)
+      if (url_scheme == scheme) {
         return true;
+      }
     }
     return false;
   }
@@ -272,8 +275,9 @@ void SaveCookies(const CefBrowserContext::Getter& browser_context_getter,
   // Match the logic in
   // URLRequestHttpJob::SaveCookiesAndNotifyHeadersComplete.
   base::Time response_date;
-  if (!headers->GetDateValue(&response_date))
+  if (!headers->GetDateValue(&response_date)) {
     response_date = base::Time();
+  }
 
   const base::StringPiece name(net_service::kHTTPSetCookieHeaderName);
   std::string cookie_string;
@@ -295,8 +299,9 @@ void SaveCookies(const CefBrowserContext::Getter& browser_context_getter,
 
     bool allow = false;
     allow_cookie_callback.Run(*cookie, &allow);
-    if (allow)
+    if (allow) {
       allowed_cookies.push_back(*cookie);
+    }
   }
 
   if (!allowed_cookies.empty()) {
diff --git a/libcef/browser/net_service/cookie_manager_impl.cc b/libcef/browser/net_service/cookie_manager_impl.cc
index 2c2610b00..00593be9d 100644
--- a/libcef/browser/net_service/cookie_manager_impl.cc
+++ b/libcef/browser/net_service/cookie_manager_impl.cc
@@ -37,8 +37,9 @@ CookieManager* GetCookieManager(CefBrowserContext* browser_context) {
 
 // Always execute the callback asynchronously.
 void RunAsyncCompletionOnUIThread(CefRefPtr<CefCompletionCallback> callback) {
-  if (!callback.get())
+  if (!callback.get()) {
     return;
+  }
   CEF_POST_TASK(CEF_UIT, base::BindOnce(&CefCompletionCallback::OnComplete,
                                         callback.get()));
 }
@@ -46,8 +47,9 @@ void RunAsyncCompletionOnUIThread(CefRefPtr<CefCompletionCallback> callback) {
 // Always execute the callback asynchronously.
 void SetCookieCallbackImpl(CefRefPtr<CefSetCookieCallback> callback,
                            net::CookieAccessResult access_result) {
-  if (!callback.get())
+  if (!callback.get()) {
     return;
+  }
   const bool is_include = access_result.status.IsInclude();
   if (!is_include) {
     LOG(WARNING) << "SetCookie failed with reason: "
@@ -60,8 +62,9 @@ void SetCookieCallbackImpl(CefRefPtr<CefSetCookieCallback> callback,
 // Always execute the callback asynchronously.
 void DeleteCookiesCallbackImpl(CefRefPtr<CefDeleteCookiesCallback> callback,
                                uint32_t num_deleted) {
-  if (!callback.get())
+  if (!callback.get()) {
     return;
+  }
   CEF_POST_TASK(CEF_UIT, base::BindOnce(&CefDeleteCookiesCallback::OnComplete,
                                         callback.get(), num_deleted));
 }
@@ -72,8 +75,9 @@ void ExecuteVisitor(CefRefPtr<CefCookieVisitor> visitor,
   CEF_REQUIRE_UIT();
 
   auto browser_context = GetBrowserContext(browser_context_getter);
-  if (!browser_context)
+  if (!browser_context) {
     return;
+  }
 
   auto cookie_manager = GetCookieManager(browser_context);
 
@@ -88,8 +92,9 @@ void ExecuteVisitor(CefRefPtr<CefCookieVisitor> visitor,
       cookie_manager->DeleteCanonicalCookie(
           cc, CookieManager::DeleteCanonicalCookieCallback());
     }
-    if (!keepLooping)
+    if (!keepLooping) {
       break;
+    }
     count++;
   }
 }
@@ -141,8 +146,9 @@ void CefCookieManagerImpl::Initialize(
 
 bool CefCookieManagerImpl::VisitAllCookies(
     CefRefPtr<CefCookieVisitor> visitor) {
-  if (!visitor.get())
+  if (!visitor.get()) {
     return false;
+  }
 
   if (!ValidContext()) {
     StoreOrTriggerInitCallback(base::BindOnce(
@@ -158,12 +164,14 @@ bool CefCookieManagerImpl::VisitUrlCookies(
     const CefString& url,
     bool includeHttpOnly,
     CefRefPtr<CefCookieVisitor> visitor) {
-  if (!visitor.get())
+  if (!visitor.get()) {
     return false;
+  }
 
   GURL gurl = GURL(url.ToString());
-  if (!gurl.is_valid())
+  if (!gurl.is_valid()) {
     return false;
+  }
 
   if (!ValidContext()) {
     StoreOrTriggerInitCallback(base::BindOnce(
@@ -179,8 +187,9 @@ bool CefCookieManagerImpl::SetCookie(const CefString& url,
                                      const CefCookie& cookie,
                                      CefRefPtr<CefSetCookieCallback> callback) {
   GURL gurl = GURL(url.ToString());
-  if (!gurl.is_valid())
+  if (!gurl.is_valid()) {
     return false;
+  }
 
   if (!ValidContext()) {
     StoreOrTriggerInitCallback(base::BindOnce(
@@ -198,8 +207,9 @@ bool CefCookieManagerImpl::DeleteCookies(
     CefRefPtr<CefDeleteCookiesCallback> callback) {
   // Empty URLs are allowed but not invalid URLs.
   GURL gurl = GURL(url.ToString());
-  if (!gurl.is_empty() && !gurl.is_valid())
+  if (!gurl.is_empty() && !gurl.is_valid()) {
     return false;
+  }
 
   if (!ValidContext()) {
     StoreOrTriggerInitCallback(base::BindOnce(
@@ -229,8 +239,9 @@ bool CefCookieManagerImpl::VisitAllCookiesInternal(
   DCHECK(visitor);
 
   auto browser_context = GetBrowserContext(browser_context_getter_);
-  if (!browser_context)
+  if (!browser_context) {
     return false;
+  }
 
   GetCookieManager(browser_context)
       ->GetAllCookies(base::BindOnce(&GetAllCookiesCallbackImpl, visitor,
@@ -247,14 +258,16 @@ bool CefCookieManagerImpl::VisitUrlCookiesInternal(
   DCHECK(url.is_valid());
 
   net::CookieOptions options;
-  if (includeHttpOnly)
+  if (includeHttpOnly) {
     options.set_include_httponly();
+  }
   options.set_same_site_cookie_context(
       net::CookieOptions::SameSiteCookieContext::MakeInclusive());
 
   auto browser_context = GetBrowserContext(browser_context_getter_);
-  if (!browser_context)
+  if (!browser_context) {
     return false;
+  }
 
   GetCookieManager(browser_context)
       ->GetCookieList(url, options, net::CookiePartitionKeyCollection(),
@@ -276,8 +289,9 @@ bool CefCookieManagerImpl::SetCookieInternal(
   std::string path = CefString(&cookie.path).ToString();
 
   base::Time expiration_time;
-  if (cookie.has_expires)
+  if (cookie.has_expires) {
     expiration_time = CefBaseTime(cookie.expires);
+  }
 
   net::CookieSameSite same_site =
       net_service::MakeCookieSameSite(cookie.same_site);
@@ -300,14 +314,16 @@ bool CefCookieManagerImpl::SetCookieInternal(
   }
 
   net::CookieOptions options;
-  if (cookie.httponly)
+  if (cookie.httponly) {
     options.set_include_httponly();
+  }
   options.set_same_site_cookie_context(
       net::CookieOptions::SameSiteCookieContext::MakeInclusive());
 
   auto browser_context = GetBrowserContext(browser_context_getter_);
-  if (!browser_context)
+  if (!browser_context) {
     return false;
+  }
 
   GetCookieManager(browser_context)
       ->SetCanonicalCookie(*canonical_cookie, url, options,
@@ -337,8 +353,9 @@ bool CefCookieManagerImpl::DeleteCookiesInternal(
   }
 
   auto browser_context = GetBrowserContext(browser_context_getter_);
-  if (!browser_context)
+  if (!browser_context) {
     return false;
+  }
 
   GetCookieManager(browser_context)
       ->DeleteCookies(std::move(deletion_filter),
@@ -351,8 +368,9 @@ bool CefCookieManagerImpl::FlushStoreInternal(
   DCHECK(ValidContext());
 
   auto browser_context = GetBrowserContext(browser_context_getter_);
-  if (!browser_context)
+  if (!browser_context) {
     return false;
+  }
 
   GetCookieManager(browser_context)
       ->FlushCookieStore(
diff --git a/libcef/browser/net_service/proxy_url_loader_factory.cc b/libcef/browser/net_service/proxy_url_loader_factory.cc
index e30a4955e..0638f3a26 100644
--- a/libcef/browser/net_service/proxy_url_loader_factory.cc
+++ b/libcef/browser/net_service/proxy_url_loader_factory.cc
@@ -428,8 +428,9 @@ InterceptedRequest::InterceptedRequest(
 }
 
 InterceptedRequest::~InterceptedRequest() {
-  if (status_.error_code != net::OK)
+  if (status_.error_code != net::OK) {
     SendErrorCallback(status_.error_code, false);
+  }
   if (on_headers_received_callback_) {
     std::move(on_headers_received_callback_)
         .Run(net::ERR_ABORTED, absl::nullopt, GURL());
@@ -443,8 +444,9 @@ void InterceptedRequest::Restart() {
     target_loader_.reset();
   }
 
-  if (header_client_receiver_.is_bound())
+  if (header_client_receiver_.is_bound()) {
     std::ignore = header_client_receiver_.Unbind();
+  }
 
   current_request_uses_header_client_ =
       factory_->url_loader_header_client_receiver_.is_bound();
@@ -500,8 +502,9 @@ void InterceptedRequest::InputStreamFailed(bool restart_needed) {
     return;
   }
 
-  if (!restart_needed)
+  if (!restart_needed) {
     return;
+  }
 
   input_stream_previously_failed_ = true;
   Restart();
@@ -521,8 +524,9 @@ void InterceptedRequest::OnBeforeSendHeaders(
   std::move(callback).Run(net::OK, absl::nullopt);
 
   // Resume handling of client messages after continuing from an async callback.
-  if (proxied_client_receiver_.is_bound())
+  if (proxied_client_receiver_.is_bound()) {
     proxied_client_receiver_.Resume();
+  }
 }
 
 void InterceptedRequest::OnHeadersReceived(
@@ -685,8 +689,9 @@ void InterceptedRequest::FollowRedirect(
   // If |OnURLLoaderClientError| was called then we're just waiting for the
   // connection error handler of |proxied_loader_receiver_|. Don't restart the
   // job since that'll create another URLLoader.
-  if (!target_client_)
+  if (!target_client_) {
     return;
+  }
 
   // Normally we would call FollowRedirect on the target loader and it would
   // begin loading the redirected request. However, the client might want to
@@ -696,18 +701,21 @@ void InterceptedRequest::FollowRedirect(
 
 void InterceptedRequest::SetPriority(net::RequestPriority priority,
                                      int32_t intra_priority_value) {
-  if (target_loader_)
+  if (target_loader_) {
     target_loader_->SetPriority(priority, intra_priority_value);
+  }
 }
 
 void InterceptedRequest::PauseReadingBodyFromNet() {
-  if (target_loader_)
+  if (target_loader_) {
     target_loader_->PauseReadingBodyFromNet();
+  }
 }
 
 void InterceptedRequest::ResumeReadingBodyFromNet() {
-  if (target_loader_)
+  if (target_loader_) {
     target_loader_->ResumeReadingBodyFromNet();
+  }
 }
 
 // Helper methods.
@@ -828,8 +836,9 @@ void InterceptedRequest::HandleResponseOrRedirectHeaders(
   redirect_url_ = redirect_info.has_value() ? redirect_info->new_url : GURL();
   original_url_ = request_.url;
 
-  if (!redirect_url_.is_empty())
+  if (!redirect_url_.is_empty()) {
     redirect_in_progress_ = true;
+  }
 
   // |current_response_| may be nullptr when called from OnHeadersReceived.
   auto headers =
@@ -841,8 +850,9 @@ void InterceptedRequest::HandleResponseOrRedirectHeaders(
       id_, request_, redirect_url_, headers.get());
 
   // Pause handling of client messages before waiting on an async callback.
-  if (proxied_client_receiver_.is_bound())
+  if (proxied_client_receiver_.is_bound()) {
     proxied_client_receiver_.Pause();
+  }
 
   factory_->request_handler_->OnRequestResponse(
       id_, &request_, headers.get(), redirect_info,
@@ -884,8 +894,9 @@ void InterceptedRequest::ContinueToHandleOverrideHeaders(int error_code) {
 
   DCHECK(on_headers_received_callback_);
   absl::optional<std::string> headers;
-  if (override_headers_)
+  if (override_headers_) {
     headers = override_headers_->raw_headers();
+  }
   header_client_redirect_url_ = redirect_url_;
   std::move(on_headers_received_callback_).Run(net::OK, headers, redirect_url_);
 
@@ -893,8 +904,9 @@ void InterceptedRequest::ContinueToHandleOverrideHeaders(int error_code) {
   redirect_url_ = GURL();
 
   // Resume handling of client messages after continuing from an async callback.
-  if (proxied_client_receiver_.is_bound())
+  if (proxied_client_receiver_.is_bound()) {
     proxied_client_receiver_.Resume();
+  }
 }
 
 net::RedirectInfo InterceptedRequest::MakeRedirectResponseAndInfo(
@@ -932,16 +944,18 @@ void InterceptedRequest::ContinueToBeforeRedirect(
   request_was_redirected_ = true;
   redirect_in_progress_ = false;
 
-  if (header_client_redirect_url_.is_valid())
+  if (header_client_redirect_url_.is_valid()) {
     header_client_redirect_url_ = GURL();
+  }
 
   const GURL redirect_url = redirect_url_;
   override_headers_ = nullptr;
   redirect_url_ = GURL();
 
   // Resume handling of client messages after continuing from an async callback.
-  if (proxied_client_receiver_.is_bound())
+  if (proxied_client_receiver_.is_bound()) {
     proxied_client_receiver_.Resume();
+  }
 
   const auto original_url = request_.url;
   const auto original_method = request_.method;
@@ -1045,8 +1059,9 @@ void InterceptedRequest::ContinueToResponseStarted(int error_code) {
 
     // Resume handling of client messages after continuing from an async
     // callback.
-    if (proxied_client_receiver_.is_bound())
+    if (proxied_client_receiver_.is_bound()) {
       proxied_client_receiver_.Resume();
+    }
 
     target_client_->OnReceiveResponse(
         std::move(current_response_),
@@ -1075,8 +1090,9 @@ void InterceptedRequest::OnProcessRequestHeaders(
 
   if (!modified_headers->IsEmpty() || !removed_headers->empty()) {
     request_.headers.MergeFrom(*modified_headers);
-    for (const std::string& name : *removed_headers)
+    for (const std::string& name : *removed_headers) {
       request_.headers.RemoveHeader(name);
+    }
   }
 }
 
@@ -1090,15 +1106,17 @@ void InterceptedRequest::OnURLLoaderClientError() {
 
 void InterceptedRequest::OnURLLoaderError(uint32_t custom_reason,
                                           const std::string& description) {
-  if (custom_reason == network::mojom::URLLoader::kClientDisconnectReason)
+  if (custom_reason == network::mojom::URLLoader::kClientDisconnectReason) {
     SendErrorCallback(safe_browsing::kNetErrorCodeForSafeBrowsing, true);
+  }
 
   got_loader_error_ = true;
 
   // If CallOnComplete was already called, then this object is ready to be
   // deleted.
-  if (!target_client_)
+  if (!target_client_) {
     OnDestroy();
+  }
 }
 
 void InterceptedRequest::CallOnComplete(
@@ -1106,8 +1124,9 @@ void InterceptedRequest::CallOnComplete(
     bool wait_for_loader_error) {
   status_ = status;
 
-  if (target_client_)
+  if (target_client_) {
     target_client_->OnComplete(status);
+  }
 
   if (proxied_loader_receiver_.is_bound() &&
       (wait_for_loader_error && !got_loader_error_)) {
@@ -1149,8 +1168,9 @@ void InterceptedRequest::SendErrorCallback(int error_code,
                                            bool safebrowsing_hit) {
   // Ensure we only send one error callback, e.g. to avoid sending two if
   // there's both a networking error and safe browsing blocked the request.
-  if (sent_error_callback_)
+  if (sent_error_callback_) {
     return;
+  }
 
   sent_error_callback_ = true;
   factory_->request_handler_->OnRequestError(id_, request_, error_code,
@@ -1228,8 +1248,9 @@ ProxyURLLoaderFactory::ProxyURLLoaderFactory(
   proxy_receivers_.set_disconnect_handler(base::BindRepeating(
       &ProxyURLLoaderFactory::OnProxyBindingError, base::Unretained(this)));
 
-  if (header_client_receiver)
+  if (header_client_receiver) {
     url_loader_header_client_receiver_.Bind(std::move(header_client_receiver));
+  }
 }
 
 ProxyURLLoaderFactory::~ProxyURLLoaderFactory() {
@@ -1275,8 +1296,9 @@ void ProxyURLLoaderFactory::CreateProxy(
 
   mojo::PendingReceiver<network::mojom::TrustedURLLoaderHeaderClient>
       header_client_receiver;
-  if (header_client)
+  if (header_client) {
     header_client_receiver = header_client->InitWithNewPipeAndPassReceiver();
+  }
 
   content::ResourceContext* resource_context =
       browser_context->GetResourceContext();
@@ -1362,8 +1384,9 @@ void ProxyURLLoaderFactory::OnLoaderCreated(
     mojo::PendingReceiver<network::mojom::TrustedHeaderClient> receiver) {
   CEF_REQUIRE_IOT();
   auto request_it = requests_.find(request_id);
-  if (request_it != requests_.end())
+  if (request_it != requests_.end()) {
     request_it->second->OnLoaderCreated(std::move(receiver));
+  }
 }
 
 void ProxyURLLoaderFactory::OnLoaderForCorsPreflightCreated(
@@ -1382,8 +1405,9 @@ void ProxyURLLoaderFactory::OnTargetFactoryError() {
 }
 
 void ProxyURLLoaderFactory::OnProxyBindingError() {
-  if (proxy_receivers_.empty())
+  if (proxy_receivers_.empty()) {
     target_factory_.reset();
+  }
 
   MaybeDestroySelf();
 }
@@ -1399,8 +1423,9 @@ void ProxyURLLoaderFactory::RemoveRequest(InterceptedRequest* request) {
 void ProxyURLLoaderFactory::MaybeDestroySelf() {
   // Even if all URLLoaderFactory pipes connected to this object have been
   // closed it has to stay alive until all active requests have completed.
-  if (target_factory_.is_bound() || !requests_.empty())
+  if (target_factory_.is_bound() || !requests_.empty()) {
     return;
+  }
 
   destroyed_ = true;
 
diff --git a/libcef/browser/net_service/resource_handler_wrapper.cc b/libcef/browser/net_service/resource_handler_wrapper.cc
index bb14e4f69..37e72b060 100644
--- a/libcef/browser/net_service/resource_handler_wrapper.cc
+++ b/libcef/browser/net_service/resource_handler_wrapper.cc
@@ -113,8 +113,9 @@ class HandlerProvider : public base::RefCountedThreadSafe<HandlerProvider> {
 
   void Detach() {
     base::AutoLock lock_scope(lock_);
-    if (!handler_)
+    if (!handler_) {
       return;
+    }
 
     // Execute on the expected thread.
     CEF_POST_TASK(CEF_IOT,
@@ -186,8 +187,9 @@ class ReadResponseCallbackWrapper : public CefCallback {
 
   void DoRead() {
     CEF_REQUIRE_IOT();
-    if (!callback_)
+    if (!callback_) {
       return;
+    }
 
     auto handler = handler_provider_->handler();
     if (!handler) {
@@ -489,8 +491,9 @@ class ResourceResponseWrapper : public ResourceResponse {
 
     // A |content_length| value may already be specified if the request included
     // a Range header.
-    if (response_length >= 0 && *content_length == -1)
+    if (response_length >= 0 && *content_length == -1) {
       *content_length = response_length;
+    }
 
     CefResponse::HeaderMap headerMap;
     response->GetHeaderMap(headerMap);
diff --git a/libcef/browser/net_service/resource_request_handler_wrapper.cc b/libcef/browser/net_service/resource_request_handler_wrapper.cc
index 9dff7c1f4..3b971b5c4 100644
--- a/libcef/browser/net_service/resource_request_handler_wrapper.cc
+++ b/libcef/browser/net_service/resource_request_handler_wrapper.cc
@@ -165,15 +165,17 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
 
     virtual ~DestructionObserver() {
       CEF_REQUIRE_UIT();
-      if (!registered_)
+      if (!registered_) {
         return;
+      }
 
       // Verify that the browser or context still exists before attempting to
       // remove the observer.
       if (browser_info_) {
         auto browser = browser_info_->browser();
-        if (browser)
+        if (browser) {
           browser->RemoveObserver(this);
+        }
       } else if (CefContext::Get()) {
         // Network requests may be torn down during shutdown, so we can't check
         // CONTEXT_STATE_VALID() here.
@@ -345,8 +347,9 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
       base::AutoLock lock_scope(lock_);
       // May be nullptr if the InterceptedRequestHandlerWrapper has already
       // been deleted.
-      if (!wrapper_)
+      if (!wrapper_) {
         return;
+      }
       wrapper_->SetInitialized(std::move(init_state));
       wrapper_ = nullptr;
     }
@@ -401,8 +404,9 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
 
     // Continue any pending requests.
     if (!pending_requests_.empty()) {
-      for (const auto& request : pending_requests_)
+      for (const auto& request : pending_requests_) {
         request->Run(this);
+      }
       pending_requests_.clear();
     }
   }
@@ -555,8 +559,9 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
 
     // True if there's a possibility that the client might handle the request.
     const bool maybe_intercept_request = handler || scheme_factory;
-    if (!maybe_intercept_request && requestPtr)
+    if (!maybe_intercept_request && requestPtr) {
       requestPtr = nullptr;
+    }
 
     // May have a handler and/or scheme factory.
     state->Reset(handler, scheme_factory, requestPtr, request_was_redirected,
@@ -812,16 +817,19 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
       return;
     }
 
-    if (!state->handler_)
+    if (!state->handler_) {
       return;
+    }
 
-    if (!state->pending_response_)
+    if (!state->pending_response_) {
       state->pending_response_ = new CefResponseImpl();
-    else
+    } else {
       state->pending_response_->SetReadOnly(false);
+    }
 
-    if (headers)
+    if (headers) {
       state->pending_response_->SetResponseHeaders(*headers);
+    }
 
     state->pending_response_->SetReadOnly(true);
   }
@@ -1120,8 +1128,9 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
  private:
   void CallHandlerOnComplete(RequestState* state,
                              const network::URLLoaderCompletionStatus& status) {
-    if (!state->handler_ || !state->pending_request_)
+    if (!state->handler_ || !state->pending_request_) {
       return;
+    }
 
     // The request object may be currently flagged as writable in cases where we
     // abort a request that is waiting on a pending callack.
@@ -1178,8 +1187,9 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
           init_state_->iothread_state_->GetHandler(
               init_state_->global_id_, /*require_frame_match=*/false);
       if (context_handler) {
-        if (!requestPtr)
+        if (!requestPtr) {
           requestPtr = MakeRequest(request, request_id, true);
+        }
 
         handler = context_handler->GetResourceRequestHandler(
             init_state_->browser_, init_state_->frame_, requestPtr.get(),
@@ -1202,16 +1212,18 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
 
   RequestState* GetState(int32_t request_id) const {
     RequestMap::const_iterator it = request_map_.find(request_id);
-    if (it != request_map_.end())
+    if (it != request_map_.end()) {
       return it->second.get();
+    }
     return nullptr;
   }
 
   void RemoveState(int32_t request_id) {
     RequestMap::iterator it = request_map_.find(request_id);
     DCHECK(it != request_map_.end());
-    if (it != request_map_.end())
+    if (it != request_map_.end()) {
       request_map_.erase(it);
+    }
   }
 
   // Stop accepting new requests and cancel pending/in-flight requests when the
@@ -1269,10 +1281,11 @@ class InterceptedRequestHandlerWrapper : public InterceptedRequestHandler {
       bool read_only) {
     CefRefPtr<CefRequestImpl> requestPtr = new CefRequestImpl();
     requestPtr->Set(request, request_id);
-    if (read_only)
+    if (read_only) {
       requestPtr->SetReadOnly(true);
-    else
+    } else {
       requestPtr->SetTrackChanges(true);
+    }
     return requestPtr;
   }
 
@@ -1399,8 +1412,9 @@ std::unique_ptr<InterceptedRequestHandler> CreateInterceptedRequestHandler(
   // TODO(navigation): Can we determine the |is_download| value?
   const bool is_download = false;
   url::Origin request_initiator;
-  if (request.request_initiator.has_value())
+  if (request.request_initiator.has_value()) {
     request_initiator = *request.request_initiator;
+  }
 
   auto init_state =
       std::make_unique<InterceptedRequestHandlerWrapper::InitState>();
diff --git a/libcef/browser/net_service/response_filter_wrapper.cc b/libcef/browser/net_service/response_filter_wrapper.cc
index 3769d83e3..bc185a1b3 100644
--- a/libcef/browser/net_service/response_filter_wrapper.cc
+++ b/libcef/browser/net_service/response_filter_wrapper.cc
@@ -142,8 +142,9 @@ void ResponseFilterWrapper::Filter(const char* data, size_t size) {
     last_status_ = filter_->Filter(
         const_cast<char*>(data_in_ptr), data_in_size, data_in_read,
         const_cast<char*>(data_out_ptr), data_out_size, data_out_written);
-    if (last_status_ == RESPONSE_FILTER_ERROR)
+    if (last_status_ == RESPONSE_FILTER_ERROR) {
       break;
+    }
 
     // Validate the out values.
     if (data_in_read > data_in_size) {
@@ -268,13 +269,15 @@ void ResponseFilterWrapper::MaybeSuccess() {
     return;
   }
 
-  if (!read_pending_ && !write_pending_)
+  if (!read_pending_ && !write_pending_) {
     Cleanup(true);
+  }
 }
 
 void ResponseFilterWrapper::Cleanup(bool success) {
-  if (!success && error_callback_)
+  if (!success && error_callback_) {
     std::move(error_callback_).Run();
+  }
   delete this;
 }
 
@@ -290,8 +293,9 @@ mojo::ScopedDataPipeConsumerHandle CreateResponseFilterHandler(
   auto filter_wrapper = new ResponseFilterWrapper(
       filter, std::move(source_handle), std::move(error_callback));
   mojo::ScopedDataPipeConsumerHandle output_handle;
-  if (!filter_wrapper->CreateOutputHandle(&output_handle))
+  if (!filter_wrapper->CreateOutputHandle(&output_handle)) {
     delete filter_wrapper;
+  }
   return output_handle;
 }
 
diff --git a/libcef/browser/net_service/stream_reader_url_loader.cc b/libcef/browser/net_service/stream_reader_url_loader.cc
index 45680d918..a61ad2dc1 100644
--- a/libcef/browser/net_service/stream_reader_url_loader.cc
+++ b/libcef/browser/net_service/stream_reader_url_loader.cc
@@ -79,8 +79,9 @@ class OpenInputStreamWrapper
 
   void CancelOnJobThread() {
     DCHECK(job_thread_task_runner_->RunsTasksInCurrentSequence());
-    if (callback_.is_null())
+    if (callback_.is_null()) {
       return;
+    }
 
     callback_.Reset();
 
@@ -91,8 +92,9 @@ class OpenInputStreamWrapper
 
   void CancelOnWorkThread() {
     DCHECK(work_thread_task_runner_->RunsTasksInCurrentSequence());
-    if (is_canceled_)
+    if (is_canceled_) {
       return;
+    }
     is_canceled_ = true;
     OnCallback(nullptr);
   }
@@ -100,8 +102,9 @@ class OpenInputStreamWrapper
   void OpenOnWorkThread(int32_t request_id,
                         const network::ResourceRequest& request) {
     DCHECK(work_thread_task_runner_->RunsTasksInCurrentSequence());
-    if (is_canceled_)
+    if (is_canceled_) {
       return;
+    }
 
     // |delegate_| will remain valid until OnCallback() is executed on
     // |job_thread_task_runner_|.
@@ -312,8 +315,9 @@ void InputStreamReader::ReadOnWorkThread(scoped_refptr<net::IOBuffer> dest,
                      pending_callback_id_));
 
   // Check if the callback will execute asynchronously.
-  if (result && bytes_read == 0)
+  if (result && bytes_read == 0) {
     return;
+  }
 
   RunReadCallback(result || bytes_read <= 0 ? bytes_read : net::ERR_FAILED);
 }
@@ -335,8 +339,9 @@ void InputStreamReader::SkipToRequestedRange() {
                        pending_callback_id_));
 
     // Check if the callback will execute asynchronously.
-    if (result && skipped == 0)
+    if (result && skipped == 0) {
       return;
+    }
 
     if (!result || skipped <= 0) {
       RunSkipCallback(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE);
@@ -383,13 +388,15 @@ void InputStreamReader::ContinueSkipCallbackOnWorkThread(
   DCHECK(work_thread_task_runner_->RunsTasksInCurrentSequence());
 
   // Check for out of order callbacks.
-  if (pending_callback_id_ != callback_id)
+  if (pending_callback_id_ != callback_id) {
     return;
+  }
 
   DCHECK_LE(bytes_skipped, bytes_to_skip_);
 
-  if (bytes_to_skip_ > 0 && bytes_skipped > 0)
+  if (bytes_to_skip_ > 0 && bytes_skipped > 0) {
     bytes_to_skip_ -= bytes_skipped;
+  }
 
   if (bytes_skipped <= 0) {
     RunSkipCallback(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE);
@@ -409,8 +416,9 @@ void InputStreamReader::ContinueReadCallbackOnWorkThread(int callback_id,
   DCHECK(work_thread_task_runner_->RunsTasksInCurrentSequence());
 
   // Check for out of order callbacks.
-  if (pending_callback_id_ != callback_id)
+  if (pending_callback_id_ != callback_id) {
     return;
+  }
 
   RunReadCallback(bytes_read);
 }
@@ -637,13 +645,15 @@ void StreamReaderURLLoader::HeadersComplete(int orig_status_code,
       extra_headers, false /* allow_existing_header_override */);
   pending_response->headers = headers;
 
-  if (content_length >= 0)
+  if (content_length >= 0) {
     pending_response->content_length = content_length;
+  }
 
   if (!mime_type.empty()) {
     pending_response->mime_type = mime_type;
-    if (!charset.empty())
+    if (!charset.empty()) {
       pending_response->charset = charset;
+    }
   }
 
   if (header_client_.is_bound()) {
@@ -826,8 +836,9 @@ bool StreamReaderURLLoader::ParseRange(const net::HttpRequestHeaders& headers) {
     if (net::HttpUtil::ParseRangeHeader(range_header, &ranges)) {
       // In case of multi-range request only use the first range.
       // We don't support multirange requests.
-      if (ranges.size() == 1)
+      if (ranges.size() == 1) {
         byte_range_ = ranges[0];
+      }
     } else {
       // This happens if the range header could not be parsed or is invalid.
       return false;
diff --git a/libcef/browser/net_service/url_loader_factory_getter.cc b/libcef/browser/net_service/url_loader_factory_getter.cc
index b6a4c3f76..bb7a548e6 100644
--- a/libcef/browser/net_service/url_loader_factory_getter.cc
+++ b/libcef/browser/net_service/url_loader_factory_getter.cc
@@ -95,8 +95,9 @@ URLLoaderFactoryGetter::GetURLLoaderFactory() {
     DCHECK(task_runner_->RunsTasksInCurrentSequence());
   }
 
-  if (lazy_factory_)
+  if (lazy_factory_) {
     return lazy_factory_;
+  }
 
   // Bind on the current thread.
   auto loader_factory =
diff --git a/libcef/browser/origin_whitelist_impl.cc b/libcef/browser/origin_whitelist_impl.cc
index 7bb83b875..01bef97e0 100644
--- a/libcef/browser/origin_whitelist_impl.cc
+++ b/libcef/browser/origin_whitelist_impl.cc
@@ -52,8 +52,9 @@ class CefOriginWhitelistManager {
 
       // Verify that the origin entry doesn't already exist.
       for (const auto& entry : origin_list_) {
-        if (entry == info)
+        if (entry == info) {
           return false;
+        }
       }
 
       origin_list_.push_back(info->Clone());
@@ -88,8 +89,9 @@ class CefOriginWhitelistManager {
       }
     }
 
-    if (!found)
+    if (!found) {
       return false;
+    }
 
     SendModifyCrossOriginWhitelistEntry(false, info);
     return true;
@@ -123,8 +125,9 @@ class CefOriginWhitelistManager {
 
     if (!origin_list_.empty()) {
       for (const auto& entry : origin_list_) {
-        if (IsMatch(source, target, entry))
+        if (IsMatch(source, target, entry)) {
           return true;
+        }
       }
     }
 
diff --git a/libcef/browser/osr/browser_platform_delegate_osr.cc b/libcef/browser/osr/browser_platform_delegate_osr.cc
index 624b4becd..58e6454df 100644
--- a/libcef/browser/osr/browser_platform_delegate_osr.cc
+++ b/libcef/browser/osr/browser_platform_delegate_osr.cc
@@ -57,8 +57,9 @@ void CefBrowserPlatformDelegateOsr::WebContentsCreated(
 
 void CefBrowserPlatformDelegateOsr::RenderViewCreated(
     content::RenderViewHost* render_view_host) {
-  if (view_osr_)
+  if (view_osr_) {
     view_osr_->RenderViewCreated();
+  }
 }
 
 void CefBrowserPlatformDelegateOsr::BrowserCreated(
@@ -105,14 +106,16 @@ SkColor CefBrowserPlatformDelegateOsr::GetBackgroundColor() const {
 
 void CefBrowserPlatformDelegateOsr::WasResized() {
   CefRenderWidgetHostViewOSR* view = GetOSRHostView();
-  if (view)
+  if (view) {
     view->WasResized();
+  }
 }
 
 void CefBrowserPlatformDelegateOsr::SendKeyEvent(const CefKeyEvent& event) {
   CefRenderWidgetHostViewOSR* view = GetOSRHostView();
-  if (!view)
+  if (!view) {
     return;
+  }
 
   content::NativeWebKeyboardEvent web_event =
       native_delegate_->TranslateWebKeyEvent(event);
@@ -125,8 +128,9 @@ void CefBrowserPlatformDelegateOsr::SendMouseClickEvent(
     bool mouseUp,
     int clickCount) {
   CefRenderWidgetHostViewOSR* view = GetOSRHostView();
-  if (!view)
+  if (!view) {
     return;
+  }
 
   blink::WebMouseEvent web_event = native_delegate_->TranslateWebClickEvent(
       event, type, mouseUp, clickCount);
@@ -137,8 +141,9 @@ void CefBrowserPlatformDelegateOsr::SendMouseMoveEvent(
     const CefMouseEvent& event,
     bool mouseLeave) {
   CefRenderWidgetHostViewOSR* view = GetOSRHostView();
-  if (!view)
+  if (!view) {
     return;
+  }
 
   blink::WebMouseEvent web_event =
       native_delegate_->TranslateWebMoveEvent(event, mouseLeave);
@@ -150,8 +155,9 @@ void CefBrowserPlatformDelegateOsr::SendMouseWheelEvent(
     int deltaX,
     int deltaY) {
   CefRenderWidgetHostViewOSR* view = GetOSRHostView();
-  if (!view)
+  if (!view) {
     return;
+  }
 
   blink::WebMouseWheelEvent web_event =
       native_delegate_->TranslateWebWheelEvent(event, deltaX, deltaY);
@@ -160,14 +166,16 @@ void CefBrowserPlatformDelegateOsr::SendMouseWheelEvent(
 
 void CefBrowserPlatformDelegateOsr::SendTouchEvent(const CefTouchEvent& event) {
   CefRenderWidgetHostViewOSR* view = GetOSRHostView();
-  if (view)
+  if (view) {
     view->SendTouchEvent(event);
+  }
 }
 
 void CefBrowserPlatformDelegateOsr::SetFocus(bool setFocus) {
   CefRenderWidgetHostViewOSR* view = GetOSRHostView();
-  if (view)
+  if (view) {
     view->SetFocus(setFocus);
+  }
 }
 
 gfx::Point CefBrowserPlatformDelegateOsr::GetScreenPoint(
@@ -228,42 +236,48 @@ void CefBrowserPlatformDelegateOsr::WasHidden(bool hidden) {
   content::WebContentsImpl* web_contents =
       static_cast<content::WebContentsImpl*>(web_contents_);
   if (web_contents) {
-    if (hidden)
+    if (hidden) {
       web_contents->WasHidden();
-    else
+    } else {
       web_contents->WasShown();
+    }
   }
 }
 
 bool CefBrowserPlatformDelegateOsr::IsHidden() const {
   CefRenderWidgetHostViewOSR* view = GetOSRHostView();
-  if (view)
+  if (view) {
     return view->is_hidden();
+  }
   return true;
 }
 
 void CefBrowserPlatformDelegateOsr::NotifyScreenInfoChanged() {
   CefRenderWidgetHostViewOSR* view = GetOSRHostView();
-  if (view)
+  if (view) {
     view->OnScreenInfoChanged();
+  }
 }
 
 void CefBrowserPlatformDelegateOsr::Invalidate(cef_paint_element_type_t type) {
   CefRenderWidgetHostViewOSR* view = GetOSRHostView();
-  if (view)
+  if (view) {
     view->Invalidate(type);
+  }
 }
 
 void CefBrowserPlatformDelegateOsr::SendExternalBeginFrame() {
   CefRenderWidgetHostViewOSR* view = GetOSRHostView();
-  if (view)
+  if (view) {
     view->SendExternalBeginFrame();
+  }
 }
 
 void CefBrowserPlatformDelegateOsr::SetWindowlessFrameRate(int frame_rate) {
   CefRenderWidgetHostViewOSR* view = GetOSRHostView();
-  if (view)
+  if (view) {
     view->UpdateFrameRate();
+  }
 }
 
 void CefBrowserPlatformDelegateOsr::ImeSetComposition(
@@ -283,21 +297,24 @@ void CefBrowserPlatformDelegateOsr::ImeCommitText(
     const CefRange& replacement_range,
     int relative_cursor_pos) {
   CefRenderWidgetHostViewOSR* view = GetOSRHostView();
-  if (view)
+  if (view) {
     view->ImeCommitText(text, replacement_range, relative_cursor_pos);
+  }
 }
 
 void CefBrowserPlatformDelegateOsr::ImeFinishComposingText(
     bool keep_selection) {
   CefRenderWidgetHostViewOSR* view = GetOSRHostView();
-  if (view)
+  if (view) {
     view->ImeFinishComposingText(keep_selection);
+  }
 }
 
 void CefBrowserPlatformDelegateOsr::ImeCancelComposition() {
   CefRenderWidgetHostViewOSR* view = GetOSRHostView();
-  if (view)
+  if (view) {
     view->ImeCancelComposition();
+  }
 }
 
 void CefBrowserPlatformDelegateOsr::DragTargetDragEnter(
@@ -306,11 +323,13 @@ void CefBrowserPlatformDelegateOsr::DragTargetDragEnter(
     cef_drag_operations_mask_t allowed_ops) {
   content::WebContentsImpl* web_contents =
       static_cast<content::WebContentsImpl*>(web_contents_);
-  if (!web_contents)
+  if (!web_contents) {
     return;
+  }
 
-  if (current_rvh_for_drag_)
+  if (current_rvh_for_drag_) {
     DragTargetDragLeave();
+  }
 
   const gfx::Point client_pt(event.x, event.y);
   gfx::PointF transformed_pt;
@@ -351,13 +370,15 @@ void CefBrowserPlatformDelegateOsr::DragTargetDragEnter(
 void CefBrowserPlatformDelegateOsr::DragTargetDragOver(
     const CefMouseEvent& event,
     cef_drag_operations_mask_t allowed_ops) {
-  if (!drag_data_)
+  if (!drag_data_) {
     return;
+  }
 
   content::WebContentsImpl* web_contents =
       static_cast<content::WebContentsImpl*>(web_contents_);
-  if (!web_contents)
+  if (!web_contents) {
     return;
+  }
 
   const gfx::Point client_pt(event.x, event.y);
   const gfx::Point& screen_pt =
@@ -393,8 +414,9 @@ void CefBrowserPlatformDelegateOsr::DragTargetDragOver(
     DragTargetDragEnter(drag_data_, event, drag_allowed_ops_);
   }
 
-  if (!drag_data_)
+  if (!drag_data_) {
     return;
+  }
 
   blink::DragOperationsMask ops =
       static_cast<blink::DragOperationsMask>(allowed_ops);
@@ -419,13 +441,15 @@ void CefBrowserPlatformDelegateOsr::DragTargetDragLeave() {
 }
 
 void CefBrowserPlatformDelegateOsr::DragTargetDrop(const CefMouseEvent& event) {
-  if (!drag_data_)
+  if (!drag_data_) {
     return;
+  }
 
   content::WebContentsImpl* web_contents =
       static_cast<content::WebContentsImpl*>(web_contents_);
-  if (!web_contents)
+  if (!web_contents) {
     return;
+  }
 
   gfx::Point client_pt(event.x, event.y);
   const gfx::Point& screen_pt =
@@ -461,8 +485,9 @@ void CefBrowserPlatformDelegateOsr::DragTargetDrop(const CefMouseEvent& event) {
     DragTargetDragEnter(drag_data_, event, drag_allowed_ops_);
   }
 
-  if (!drag_data_)
+  if (!drag_data_) {
     return;
+  }
 
   {
     CefDragDataImpl* data_impl =
@@ -505,8 +530,9 @@ void CefBrowserPlatformDelegateOsr::StartDragging(
         event_info.location.x(), event_info.location.y());
   }
 
-  if (!handled)
+  if (!handled) {
     DragSourceSystemDragEnded();
+  }
 }
 
 void CefBrowserPlatformDelegateOsr::UpdateDragCursor(
@@ -523,13 +549,15 @@ void CefBrowserPlatformDelegateOsr::DragSourceEndedAt(
     int x,
     int y,
     cef_drag_operations_mask_t op) {
-  if (!drag_start_rwh_)
+  if (!drag_start_rwh_) {
     return;
+  }
 
   content::WebContentsImpl* web_contents =
       static_cast<content::WebContentsImpl*>(web_contents_);
-  if (!web_contents)
+  if (!web_contents) {
     return;
+  }
 
   content::RenderWidgetHostImpl* source_rwh = drag_start_rwh_.get();
   const gfx::Point client_loc(gfx::Point(x, y));
@@ -565,13 +593,15 @@ void CefBrowserPlatformDelegateOsr::DragSourceEndedAt(
 }
 
 void CefBrowserPlatformDelegateOsr::DragSourceSystemDragEnded() {
-  if (!drag_start_rwh_)
+  if (!drag_start_rwh_) {
     return;
+  }
 
   content::WebContentsImpl* web_contents =
       static_cast<content::WebContentsImpl*>(web_contents_);
-  if (!web_contents)
+  if (!web_contents) {
     return;
+  }
 
   web_contents->SystemDragEnded(drag_start_rwh_.get());
 
diff --git a/libcef/browser/osr/host_display_client_osr.cc b/libcef/browser/osr/host_display_client_osr.cc
index ab3541844..937f6bbda 100644
--- a/libcef/browser/osr/host_display_client_osr.cc
+++ b/libcef/browser/osr/host_display_client_osr.cc
@@ -78,8 +78,9 @@ void CefLayeredWindowUpdaterOSR::OnAllocatedSharedMemory(
   size_t expected_bytes;
   bool size_result = viz::ResourceSizes::MaybeSizeInBytes(
       pixel_size, viz::ResourceFormat::RGBA_8888, &expected_bytes);
-  if (!size_result)
+  if (!size_result) {
     return;
+  }
 
   pixel_size_ = pixel_size;
   shared_memory_ = region.Map();
diff --git a/libcef/browser/osr/motion_event_osr.cc b/libcef/browser/osr/motion_event_osr.cc
index 339d54e22..69d4b80ac 100644
--- a/libcef/browser/osr/motion_event_osr.cc
+++ b/libcef/browser/osr/motion_event_osr.cc
@@ -39,10 +39,11 @@ CefMotionEventOSR::CefMotionEventOSR() {
 CefMotionEventOSR::~CefMotionEventOSR() {}
 
 int CefMotionEventOSR::GetSourceDeviceId(size_t pointer_index) const {
-  if (IsValidIndex(pointer_index))
+  if (IsValidIndex(pointer_index)) {
     return pointer(pointer_index).source_device_id;
-  else
+  } else {
     return -1;
+  }
 }
 
 // Returns true if the touch was valid.
@@ -63,10 +64,12 @@ bool CefMotionEventOSR::OnTouch(const CefTouchEvent& touch) {
   switch (touch.type) {
     case CEF_TET_PRESSED:
       id = AddId(touch.id);
-      if (id == -1)
+      if (id == -1) {
         return false;
-      if (!AddTouch(touch, id))
+      }
+      if (!AddTouch(touch, id)) {
         return false;
+      }
       break;
 
     case CEF_TET_MOVED: {
@@ -126,15 +129,17 @@ void CefMotionEventOSR::MarkUnchangedTouchPointsAsStationary(
   if (event->GetType() == blink::WebInputEvent::Type::kTouchMove ||
       event->GetType() == blink::WebInputEvent::Type::kTouchCancel) {
     for (size_t i = 0; i < event->touches_length; ++i) {
-      if (event->touches[i].id != id)
+      if (event->touches[i].id != id) {
         event->touches[i].state = blink::WebTouchPoint::State::kStateStationary;
+      }
     }
   }
 }
 
 int CefMotionEventOSR::LookupId(int id) {
-  if (id == -1)
+  if (id == -1) {
     return -1;
+  }
 
   for (int i = 0; i < blink::WebTouchEvent::kTouchesLengthCap; i++) {
     if (id_map_[i] == id) {
@@ -145,8 +150,9 @@ int CefMotionEventOSR::LookupId(int id) {
 }
 
 int CefMotionEventOSR::AddId(int id) {
-  if (id == -1 || LookupId(id) >= 0)
+  if (id == -1 || LookupId(id) >= 0) {
     return -1;
+  }
 
   for (int i = 0; i < blink::WebTouchEvent::kTouchesLengthCap; i++) {
     if (id_map_[i] == -1) {
@@ -167,8 +173,9 @@ void CefMotionEventOSR::RemoveId(int id) {
 }
 
 bool CefMotionEventOSR::AddTouch(const CefTouchEvent& touch, int id) {
-  if (GetPointerCount() == MotionEvent::MAX_TOUCH_POINT_COUNT)
+  if (GetPointerCount() == MotionEvent::MAX_TOUCH_POINT_COUNT) {
     return false;
+  }
 
   PushPointer(GetPointerPropertiesFromTouchEvent(touch, id));
   return true;
@@ -176,8 +183,9 @@ bool CefMotionEventOSR::AddTouch(const CefTouchEvent& touch, int id) {
 
 void CefMotionEventOSR::UpdateTouch(const CefTouchEvent& touch, int id) {
   int index_to_update = FindPointerIndexOfId(id);
-  if (IsValidIndex(index_to_update))
+  if (IsValidIndex(index_to_update)) {
     pointer(index_to_update) = GetPointerPropertiesFromTouchEvent(touch, id);
+  }
 }
 
 void CefMotionEventOSR::UpdateCachedAction(const CefTouchEvent& touch, int id) {
diff --git a/libcef/browser/osr/osr_accessibility_util.cc b/libcef/browser/osr/osr_accessibility_util.cc
index d96a286d1..935a4cdb2 100644
--- a/libcef/browser/osr/osr_accessibility_util.cc
+++ b/libcef/browser/osr/osr_accessibility_util.cc
@@ -28,8 +28,9 @@ CefRefPtr<CefListValue> ToCefValue(const std::vector<T>& vecData);
 template <>
 CefRefPtr<CefListValue> ToCefValue<int>(const std::vector<int>& vecData) {
   CefRefPtr<CefListValue> value = CefListValue::Create();
-  for (size_t i = 0; i < vecData.size(); i++)
+  for (size_t i = 0; i < vecData.size(); i++) {
     value->SetInt(i, vecData[i]);
+  }
 
   return value;
 }
@@ -43,8 +44,9 @@ CefRefPtr<CefListValue> ToCefValue(uint32_t state) {
   // Iterate and find which states are set.
   for (unsigned i = static_cast<unsigned>(ax::mojom::Role::kMinValue) + 1;
        i <= static_cast<unsigned>(ax::mojom::Role::kMaxValue); i++) {
-    if (state & (1 << i))
+    if (state & (1 << i)) {
       value->SetString(index++, ToString(static_cast<ax::mojom::State>(i)));
+    }
   }
   return value;
 }
@@ -69,8 +71,9 @@ struct PopulateAxNodeAttributes {
 
   // Int Attributes
   void operator()(const std::pair<ax::mojom::IntAttribute, int32_t> attr) {
-    if (attr.first == ax::mojom::IntAttribute::kNone)
+    if (attr.first == ax::mojom::IntAttribute::kNone) {
       return;
+    }
 
     switch (attr.first) {
       case ax::mojom::IntAttribute::kNone:
@@ -201,8 +204,9 @@ struct PopulateAxNodeAttributes {
         int index = 0;
         // Iterate and find which states are set.
         for (unsigned i = 0; i < std::size(textStyleArr); i++) {
-          if (attr.second & static_cast<int>(textStyleArr[i]))
+          if (attr.second & static_cast<int>(textStyleArr[i])) {
             list->SetString(index++, ToString(textStyleArr[i]));
+          }
         }
         attributes->SetList(ToString(attr.first), list);
       } break;
@@ -225,19 +229,22 @@ struct PopulateAxNodeAttributes {
 
   // Set Bool Attributes.
   void operator()(const std::pair<ax::mojom::BoolAttribute, bool> attr) {
-    if (attr.first != ax::mojom::BoolAttribute::kNone)
+    if (attr.first != ax::mojom::BoolAttribute::kNone) {
       attributes->SetBool(ToString(attr.first), attr.second);
+    }
   }
   // Set String Attributes.
   void operator()(
       const std::pair<ax::mojom::StringAttribute, std::string>& attr) {
-    if (attr.first != ax::mojom::StringAttribute::kNone)
+    if (attr.first != ax::mojom::StringAttribute::kNone) {
       attributes->SetString(ToString(attr.first), attr.second);
+    }
   }
   // Set Float attributes.
   void operator()(const std::pair<ax::mojom::FloatAttribute, float>& attr) {
-    if (attr.first != ax::mojom::FloatAttribute::kNone)
+    if (attr.first != ax::mojom::FloatAttribute::kNone) {
       attributes->SetDouble(ToString(attr.first), attr.second);
+    }
   }
 
   // Set Int list attributes.
@@ -252,8 +259,9 @@ struct PopulateAxNodeAttributes {
         for (size_t i = 0; i < attr.second.size(); ++i) {
           auto type = static_cast<ax::mojom::MarkerType>(attr.second[i]);
 
-          if (type == ax::mojom::MarkerType::kNone)
+          if (type == ax::mojom::MarkerType::kNone) {
             continue;
+          }
 
           static ax::mojom::MarkerType marktypeArr[] = {
               ax::mojom::MarkerType::kSpelling, ax::mojom::MarkerType::kGrammar,
@@ -261,8 +269,9 @@ struct PopulateAxNodeAttributes {
 
           // Iterate and find which markers are set.
           for (unsigned j = 0; j < std::size(marktypeArr); j++) {
-            if (attr.second[i] & static_cast<int>(marktypeArr[j]))
+            if (attr.second[i] & static_cast<int>(marktypeArr[j])) {
               list->SetString(index++, ToString(marktypeArr[j]));
+            }
           }
         }
       } else {
@@ -277,8 +286,9 @@ struct PopulateAxNodeAttributes {
 CefRefPtr<CefDictionaryValue> ToCefValue(const ui::AXNodeData& node) {
   CefRefPtr<CefDictionaryValue> value = CefDictionaryValue::Create();
 
-  if (node.id != -1)
+  if (node.id != -1) {
     value->SetInt("id", node.id);
+  }
 
   value->SetString("role", ToString(node.role));
   value->SetList("state", ToCefValue(node.state));
@@ -308,13 +318,15 @@ CefRefPtr<CefDictionaryValue> ToCefValue(const ui::AXNodeData& node) {
        ++action_index) {
     auto action = static_cast<ax::mojom::Action>(action_index);
     if (node.HasAction(action)) {
-      if (!actions_strings)
+      if (!actions_strings) {
         actions_strings = CefListValue::Create();
+      }
       actions_strings->SetString(actions_idx++, ToString(action));
     }
   }
-  if (actions_strings)
+  if (actions_strings) {
     value->SetList("actions", actions_strings);
+  }
 
   CefRefPtr<CefDictionaryValue> attributes = CefDictionaryValue::Create();
   PopulateAxNodeAttributes func(attributes);
@@ -346,29 +358,37 @@ CefRefPtr<CefDictionaryValue> ToCefValue(const ui::AXNodeData& node) {
 CefRefPtr<CefDictionaryValue> ToCefValue(const ui::AXTreeData& treeData) {
   CefRefPtr<CefDictionaryValue> value = CefDictionaryValue::Create();
 
-  if (!treeData.tree_id.ToString().empty())
+  if (!treeData.tree_id.ToString().empty()) {
     value->SetString("tree_id", treeData.tree_id.ToString());
+  }
 
-  if (!treeData.parent_tree_id.ToString().empty())
+  if (!treeData.parent_tree_id.ToString().empty()) {
     value->SetString("parent_tree_id", treeData.parent_tree_id.ToString());
+  }
 
-  if (!treeData.focused_tree_id.ToString().empty())
+  if (!treeData.focused_tree_id.ToString().empty()) {
     value->SetString("focused_tree_id", treeData.focused_tree_id.ToString());
+  }
 
-  if (!treeData.doctype.empty())
+  if (!treeData.doctype.empty()) {
     value->SetString("doctype", treeData.doctype);
+  }
 
   value->SetBool("loaded", treeData.loaded);
 
-  if (treeData.loading_progress != 0.0)
+  if (treeData.loading_progress != 0.0) {
     value->SetDouble("loading_progress", treeData.loading_progress);
+  }
 
-  if (!treeData.mimetype.empty())
+  if (!treeData.mimetype.empty()) {
     value->SetString("mimetype", treeData.mimetype);
-  if (!treeData.url.empty())
+  }
+  if (!treeData.url.empty()) {
     value->SetString("url", treeData.url);
-  if (!treeData.title.empty())
+  }
+  if (!treeData.title.empty()) {
     value->SetString("title", treeData.title);
+  }
 
   if (treeData.sel_anchor_object_id != -1) {
     value->SetInt("sel_anchor_object_id", treeData.sel_anchor_object_id);
@@ -383,8 +403,9 @@ CefRefPtr<CefDictionaryValue> ToCefValue(const ui::AXTreeData& treeData) {
                      ToString(treeData.sel_anchor_affinity));
   }
 
-  if (treeData.focus_id != -1)
+  if (treeData.focus_id != -1) {
     value->SetInt("focus_id", treeData.focus_id);
+  }
 
   return value;
 }
@@ -398,11 +419,13 @@ CefRefPtr<CefDictionaryValue> ToCefValue(const ui::AXTreeUpdate& update) {
     value->SetDictionary("tree_data", ToCefValue(update.tree_data));
   }
 
-  if (update.node_id_to_clear != 0)
+  if (update.node_id_to_clear != 0) {
     value->SetInt("node_id_to_clear", update.node_id_to_clear);
+  }
 
-  if (update.root_id != 0)
+  if (update.root_id != 0) {
     value->SetInt("root_id", update.root_id);
+  }
 
   value->SetList("nodes", ToCefValue(update.nodes));
 
@@ -413,17 +436,21 @@ CefRefPtr<CefDictionaryValue> ToCefValue(const ui::AXTreeUpdate& update) {
 CefRefPtr<CefDictionaryValue> ToCefValue(const ui::AXEvent& event) {
   CefRefPtr<CefDictionaryValue> value = CefDictionaryValue::Create();
 
-  if (event.event_type != ax::mojom::Event::kNone)
+  if (event.event_type != ax::mojom::Event::kNone) {
     value->SetString("event_type", ToString(event.event_type));
+  }
 
-  if (event.id != -1)
+  if (event.id != -1) {
     value->SetInt("id", event.id);
+  }
 
-  if (event.event_from != ax::mojom::EventFrom::kNone)
+  if (event.event_from != ax::mojom::EventFrom::kNone) {
     value->SetString("event_from", ToString(event.event_from));
+  }
 
-  if (event.action_request_id != -1)
+  if (event.action_request_id != -1) {
     value->SetInt("action_request_id", event.action_request_id);
+  }
 
   return value;
 }
@@ -433,8 +460,9 @@ CefRefPtr<CefDictionaryValue> ToCefValue(
     const content::AXEventNotificationDetails& eventData) {
   CefRefPtr<CefDictionaryValue> value = CefDictionaryValue::Create();
 
-  if (!eventData.ax_tree_id.ToString().empty())
+  if (!eventData.ax_tree_id.ToString().empty()) {
     value->SetString("ax_tree_id", eventData.ax_tree_id.ToString());
+  }
 
   if (eventData.updates.size() > 0) {
     CefRefPtr<CefListValue> updates = CefListValue::Create();
@@ -464,15 +492,17 @@ CefRefPtr<CefDictionaryValue> ToCefValue(
 CefRefPtr<CefDictionaryValue> ToCefValue(const ui::AXRelativeBounds& location) {
   CefRefPtr<CefDictionaryValue> value = CefDictionaryValue::Create();
 
-  if (location.offset_container_id != -1)
+  if (location.offset_container_id != -1) {
     value->SetInt("offset_container_id", location.offset_container_id);
+  }
 
   value->SetDictionary("bounds", ToCefValue(location.bounds));
 
   // Transform matrix is private, so we set the string that Clients can parse
   // and use if needed.
-  if (location.transform && !location.transform->IsIdentity())
+  if (location.transform && !location.transform->IsIdentity()) {
     value->SetString("transform", location.transform->ToString());
+  }
 
   return value;
 }
@@ -482,11 +512,13 @@ CefRefPtr<CefDictionaryValue> ToCefValue(
     const content::AXLocationChangeNotificationDetails& locData) {
   CefRefPtr<CefDictionaryValue> value = CefDictionaryValue::Create();
 
-  if (locData.id != -1)
+  if (locData.id != -1) {
     value->SetInt("id", locData.id);
+  }
 
-  if (!locData.ax_tree_id.ToString().empty())
+  if (!locData.ax_tree_id.ToString().empty()) {
     value->SetString("ax_tree_id", locData.ax_tree_id.ToString());
+  }
 
   value->SetDictionary("new_location", ToCefValue(locData.new_location));
 
@@ -497,8 +529,9 @@ template <typename T>
 CefRefPtr<CefListValue> ToCefValue(const std::vector<T>& vecData) {
   CefRefPtr<CefListValue> value = CefListValue::Create();
 
-  for (size_t i = 0; i < vecData.size(); i++)
+  for (size_t i = 0; i < vecData.size(); i++) {
     value->SetDictionary(i, ToCefValue(vecData[i]));
+  }
 
   return value;
 }
diff --git a/libcef/browser/osr/osr_util.cc b/libcef/browser/osr/osr_util.cc
index 222ef8184..d1069b692 100644
--- a/libcef/browser/osr/osr_util.cc
+++ b/libcef/browser/osr/osr_util.cc
@@ -14,8 +14,9 @@ const int kDefaultFrameRate = 30;
 }  // namespace
 
 int ClampFrameRate(int frame_rate) {
-  if (frame_rate < 1)
+  if (frame_rate < 1) {
     return kDefaultFrameRate;
+  }
 
   return frame_rate;
 }
diff --git a/libcef/browser/osr/render_widget_host_view_osr.cc b/libcef/browser/osr/render_widget_host_view_osr.cc
index 0b88fb37e..3dca1225c 100644
--- a/libcef/browser/osr/render_widget_host_view_osr.cc
+++ b/libcef/browser/osr/render_widget_host_view_osr.cc
@@ -146,8 +146,9 @@ ui::LatencyInfo CreateLatencyInfo(const blink::WebInputEvent& event) {
 }
 
 gfx::Rect GetViewBounds(AlloyBrowserHostImpl* browser) {
-  if (!browser)
+  if (!browser) {
     return gfx::Rect();
+  }
 
   CefRect rc;
   CefRefPtr<CefRenderHandler> handler =
@@ -249,16 +250,18 @@ CefRenderWidgetHostViewOSR::CefRenderWidgetHostViewOSR(
 
   content::RenderWidgetHostImpl* render_widget_host_impl =
       content::RenderWidgetHostImpl::From(render_widget_host_);
-  if (render_widget_host_impl)
+  if (render_widget_host_impl) {
     render_widget_host_impl->SetCompositorForFlingScheduler(compositor_.get());
+  }
 
   cursor_manager_.reset(new content::CursorManager(this));
 
   // This may result in a call to GetFrameSinkId().
   render_widget_host_->SetView(this);
 
-  if (GetTextInputManager())
+  if (GetTextInputManager()) {
     GetTextInputManager()->AddObserver(this);
+  }
 
   if (render_widget_host_->delegate() &&
       render_widget_host_->delegate()->GetInputEventRouter()) {
@@ -270,8 +273,9 @@ CefRenderWidgetHostViewOSR::CefRenderWidgetHostViewOSR(
     // For child/popup views this will be called from the associated InitAs*()
     // method.
     SetRootLayerSize(false /* force */);
-    if (!render_widget_host_->is_hidden())
+    if (!render_widget_host_->is_hidden()) {
       Show();
+    }
   }
 
   selection_controller_client_ =
@@ -288,8 +292,9 @@ CefRenderWidgetHostViewOSR::~CefRenderWidgetHostViewOSR() {
   DCHECK(!child_host_view_);
   DCHECK(guest_host_views_.empty());
 
-  if (text_input_manager_)
+  if (text_input_manager_) {
     text_input_manager_->RemoveObserver(this);
+  }
 }
 
 void CefRenderWidgetHostViewOSR::ReleaseCompositor() {
@@ -355,8 +360,9 @@ bool CefRenderWidgetHostViewOSR::IsSurfaceAvailableForCopy() {
 
 void CefRenderWidgetHostViewOSR::ShowWithVisibility(
     content::PageVisibilityState) {
-  if (is_showing_)
+  if (is_showing_) {
     return;
+  }
 
   if (!content::GpuDataManagerImpl::GetInstance()->IsGpuCompositingDisabled() &&
       !browser_impl_ &&
@@ -404,8 +410,9 @@ void CefRenderWidgetHostViewOSR::ShowWithVisibility(
 }
 
 void CefRenderWidgetHostViewOSR::Hide() {
-  if (!is_showing_)
+  if (!is_showing_) {
     return;
+  }
 
   is_showing_ = false;
 
@@ -452,8 +459,9 @@ CefRenderWidgetHostViewOSR::GetTouchSelectionControllerClientManager() {
 }
 
 gfx::Rect CefRenderWidgetHostViewOSR::GetViewBounds() {
-  if (IsPopupWidget())
+  if (IsPopupWidget()) {
     return popup_position_;
+  }
 
   return current_view_bounds_;
 }
@@ -552,14 +560,16 @@ void CefRenderWidgetHostViewOSR::UpdateLocalSurfaceIdFromEmbeddedClient(
 
 const viz::LocalSurfaceId&
 CefRenderWidgetHostViewOSR::GetOrCreateLocalSurfaceId() {
-  if (!parent_local_surface_id_allocator_)
+  if (!parent_local_surface_id_allocator_) {
     AllocateLocalSurfaceId();
+  }
   return GetCurrentLocalSurfaceId();
 }
 
 void CefRenderWidgetHostViewOSR::InvalidateLocalSurfaceId() {
-  if (!parent_local_surface_id_allocator_)
+  if (!parent_local_surface_id_allocator_) {
     return;
+  }
   parent_local_surface_id_allocator_->Invalidate();
 }
 
@@ -615,8 +625,9 @@ void CefRenderWidgetHostViewOSR::InitAsPopup(
   CefRect widget_pos(client_pos.x(), client_pos.y(), client_pos.width(),
                      client_pos.height());
 
-  if (handler.get())
+  if (handler.get()) {
     handler->OnPopupSize(browser_impl_.get(), widget_pos);
+  }
 
   // The size doesn't change for popups so we need to force the
   // initialization.
@@ -632,8 +643,9 @@ content::CursorManager* CefRenderWidgetHostViewOSR::GetCursorManager() {
 }
 
 void CefRenderWidgetHostViewOSR::SetIsLoading(bool is_loading) {
-  if (!is_loading)
+  if (!is_loading) {
     return;
+  }
   // Make sure gesture detection is fresh.
   gesture_provider_.ResetDetection();
   forward_touch_to_popup_ = false;
@@ -650,16 +662,19 @@ void CefRenderWidgetHostViewOSR::Destroy() {
     if (has_parent_) {
       CancelWidget();
     } else {
-      if (popup_host_view_)
+      if (popup_host_view_) {
         popup_host_view_->CancelWidget();
-      if (child_host_view_)
+      }
+      if (child_host_view_) {
         child_host_view_->CancelWidget();
+      }
       if (!guest_host_views_.empty()) {
         // Guest RWHVs will be destroyed when the associated RWHVGuest is
         // destroyed. This parent RWHV may be destroyed first, so disassociate
         // the guest RWHVs here without destroying them.
-        for (auto guest_host_view : guest_host_views_)
+        for (auto guest_host_view : guest_host_views_) {
           guest_host_view->parent_host_view_ = nullptr;
+        }
         guest_host_views_.clear();
       }
       Hide();
@@ -671,8 +686,9 @@ void CefRenderWidgetHostViewOSR::Destroy() {
 
 void CefRenderWidgetHostViewOSR::UpdateTooltipUnderCursor(
     const std::u16string& tooltip_text) {
-  if (!browser_impl_.get())
+  if (!browser_impl_.get()) {
     return;
+  }
 
   CefString tooltip(tooltip_text);
   CefRefPtr<CefDisplayHandler> handler =
@@ -743,15 +759,17 @@ void CefRenderWidgetHostViewOSR::TransformPointToRootSurface(
     gfx::PointF* point) {}
 
 gfx::Rect CefRenderWidgetHostViewOSR::GetBoundsInRootWindow() {
-  if (!browser_impl_.get())
+  if (!browser_impl_.get()) {
     return gfx::Rect();
+  }
 
   CefRect rc;
   CefRefPtr<CefRenderHandler> handler =
       browser_impl_->client()->GetRenderHandler();
   CHECK(handler);
-  if (handler->GetRootScreenRect(browser_impl_.get(), rc))
+  if (handler->GetRootScreenRect(browser_impl_.get(), rc)) {
     return gfx::Rect(rc.x, rc.y, rc.width, rc.height);
+  }
   return GetViewBounds();
 }
 
@@ -777,8 +795,9 @@ void CefRenderWidgetHostViewOSR::ImeSetComposition(
     const CefRange& replacement_range,
     const CefRange& selection_range) {
   TRACE_EVENT0("cef", "CefRenderWidgetHostViewOSR::ImeSetComposition");
-  if (!render_widget_host_)
+  if (!render_widget_host_) {
     return;
+  }
 
   std::vector<ui::ImeTextSpan> web_underlines;
   web_underlines.reserve(underlines.size());
@@ -804,8 +823,9 @@ void CefRenderWidgetHostViewOSR::ImeCommitText(
     const CefRange& replacement_range,
     int relative_cursor_pos) {
   TRACE_EVENT0("cef", "CefRenderWidgetHostViewOSR::ImeCommitText");
-  if (!render_widget_host_)
+  if (!render_widget_host_) {
     return;
+  }
 
   gfx::Range range(replacement_range.from, replacement_range.to);
   render_widget_host_->ImeCommitText(text, std::vector<ui::ImeTextSpan>(),
@@ -817,8 +837,9 @@ void CefRenderWidgetHostViewOSR::ImeCommitText(
 
 void CefRenderWidgetHostViewOSR::ImeFinishComposingText(bool keep_selection) {
   TRACE_EVENT0("cef", "CefRenderWidgetHostViewOSR::ImeFinishComposingText");
-  if (!render_widget_host_)
+  if (!render_widget_host_) {
     return;
+  }
 
   render_widget_host_->ImeFinishComposingText(keep_selection);
 
@@ -828,8 +849,9 @@ void CefRenderWidgetHostViewOSR::ImeFinishComposingText(bool keep_selection) {
 
 void CefRenderWidgetHostViewOSR::ImeCancelComposition() {
   TRACE_EVENT0("cef", "CefRenderWidgetHostViewOSR::ImeCancelComposition");
-  if (!render_widget_host_)
+  if (!render_widget_host_) {
     return;
+  }
 
   render_widget_host_->ImeCancelComposition();
 
@@ -842,15 +864,17 @@ void CefRenderWidgetHostViewOSR::SelectionChanged(const std::u16string& text,
                                                   const gfx::Range& range) {
   RenderWidgetHostViewBase::SelectionChanged(text, offset, range);
 
-  if (!browser_impl_.get())
+  if (!browser_impl_.get()) {
     return;
+  }
 
   CefString selected_text;
   if (!range.is_empty() && !text.empty()) {
     size_t pos = range.GetMin() - offset;
     size_t n = range.length();
-    if (pos + n <= text.length())
+    if (pos + n <= text.length()) {
       selected_text = text.substr(pos, n);
+    }
   }
 
   CefRefPtr<CefRenderHandler> handler =
@@ -934,8 +958,9 @@ void CefRenderWidgetHostViewOSR::DidNavigate() {
                                   absl::nullopt);
     }
   }
-  if (delegated_frame_host_)
+  if (delegated_frame_host_) {
     delegated_frame_host_->DidNavigate();
+  }
   is_first_navigation_ = false;
 }
 
@@ -1007,8 +1032,9 @@ bool CefRenderWidgetHostViewOSR::InstallTransparency() {
 void CefRenderWidgetHostViewOSR::WasResized() {
   // Only one resize will be in-flight at a time.
   if (hold_resize_) {
-    if (!pending_resize_)
+    if (!pending_resize_) {
       pending_resize_ = true;
+    }
     return;
   }
 
@@ -1053,16 +1079,18 @@ void CefRenderWidgetHostViewOSR::SynchronizeVisualProperties(
 
 void CefRenderWidgetHostViewOSR::OnScreenInfoChanged() {
   TRACE_EVENT0("cef", "CefRenderWidgetHostViewOSR::OnScreenInfoChanged");
-  if (!render_widget_host_)
+  if (!render_widget_host_) {
     return;
+  }
 
   SynchronizeVisualProperties(cc::DeadlinePolicy::UseDefaultDeadline(),
                               absl::nullopt);
 
-  if (render_widget_host_->delegate())
+  if (render_widget_host_->delegate()) {
     render_widget_host_->delegate()->SendScreenRects();
-  else
+  } else {
     render_widget_host_->SendScreenRects();
+  }
 
   render_widget_host_->NotifyScreenInfoChanged();
 
@@ -1071,16 +1099,18 @@ void CefRenderWidgetHostViewOSR::OnScreenInfoChanged() {
   // renderer in the rwhv_aura (current_cursor_.SetScaleFactor)
 
   // Notify the guest hosts if any.
-  for (auto guest_host_view : guest_host_views_)
+  for (auto guest_host_view : guest_host_views_) {
     guest_host_view->OnScreenInfoChanged();
+  }
 }
 
 void CefRenderWidgetHostViewOSR::Invalidate(
     CefBrowserHost::PaintElementType type) {
   TRACE_EVENT1("cef", "CefRenderWidgetHostViewOSR::Invalidate", "type", type);
   if (!IsPopupWidget() && type == PET_POPUP) {
-    if (popup_host_view_)
+    if (popup_host_view_) {
       popup_host_view_->Invalidate(type);
+    }
     return;
   }
   InvalidateInternal(gfx::Rect(SizeInPixels()));
@@ -1089,8 +1119,9 @@ void CefRenderWidgetHostViewOSR::Invalidate(
 void CefRenderWidgetHostViewOSR::SendExternalBeginFrame() {
   DCHECK(external_begin_frame_enabled_);
 
-  if (begin_frame_pending_)
+  if (begin_frame_pending_) {
     return;
+  }
   begin_frame_pending_ = true;
 
   base::TimeTicks frame_time = base::TimeTicks::Now();
@@ -1104,8 +1135,9 @@ void CefRenderWidgetHostViewOSR::SendExternalBeginFrame() {
 
   DCHECK(begin_frame_args.IsValid());
 
-  if (render_widget_host_)
+  if (render_widget_host_) {
     render_widget_host_->ProgressFlingIfNeeded(frame_time);
+  }
 
   if (compositor_) {
     compositor_->IssueExternalBeginFrame(
@@ -1319,8 +1351,9 @@ void CefRenderWidgetHostViewOSR::SendTouchEvent(const CefTouchEvent& event) {
   }
 
   // Update the touch event first.
-  if (!pointer_state_.OnTouch(event))
+  if (!pointer_state_.OnTouch(event)) {
     return;
+  }
 
   if (selection_controller_->WillHandleTouchEvent(pointer_state_)) {
     pointer_state_.CleanupRemovedTouchPoints(event);
@@ -1337,11 +1370,13 @@ void CefRenderWidgetHostViewOSR::SendTouchEvent(const CefTouchEvent& event) {
 
   // Set unchanged touch point to StateStationary for touchmove and
   // touchcancel to make sure only send one ack per WebTouchEvent.
-  if (!result.succeeded)
+  if (!result.succeeded) {
     pointer_state_.MarkUnchangedTouchPointsAsStationary(&touch_event, event);
+  }
 
-  if (!render_widget_host_)
+  if (!render_widget_host_) {
     return;
+  }
 
   ui::LatencyInfo latency_info = CreateLatencyInfo(touch_event);
   if (ShouldRouteEvents()) {
@@ -1363,8 +1398,9 @@ void CefRenderWidgetHostViewOSR::SendTouchEvent(const CefTouchEvent& event) {
 }
 
 bool CefRenderWidgetHostViewOSR::ShouldRouteEvents() const {
-  if (!render_widget_host_->delegate())
+  if (!render_widget_host_->delegate()) {
     return false;
+  }
 
   // Do not route events that are currently targeted to page popups such as
   // <select> element drop-downs, since these cannot contain cross-process
@@ -1378,8 +1414,9 @@ bool CefRenderWidgetHostViewOSR::ShouldRouteEvents() const {
 }
 
 void CefRenderWidgetHostViewOSR::SetFocus(bool focus) {
-  if (!render_widget_host_)
+  if (!render_widget_host_) {
     return;
+  }
 
   content::RenderWidgetHostImpl* widget =
       content::RenderWidgetHostImpl::From(render_widget_host_);
@@ -1405,8 +1442,9 @@ void CefRenderWidgetHostViewOSR::OnUpdateTextInputStateCalled(
     content::RenderWidgetHostViewBase* updated_view,
     bool did_update_state) {
   const auto state = text_input_manager->GetTextInputState();
-  if (state && !state->show_ime_if_needed)
+  if (state && !state->show_ime_if_needed) {
     return;
+  }
 
   CefRenderHandler::TextInputMode mode = CEF_TEXT_INPUT_MODE_NONE;
   if (state && state->type != ui::TEXT_INPUT_TYPE_NONE) {
@@ -1446,8 +1484,9 @@ void CefRenderWidgetHostViewOSR::OnGestureEvent(
       ui::CreateWebGestureEventFromGestureEventData(gesture);
 
   // without this check, forwarding gestures does not work!
-  if (web_event.GetType() == blink::WebInputEvent::Type::kUndefined)
+  if (web_event.GetType() == blink::WebInputEvent::Type::kUndefined) {
     return;
+  }
 
   ui::LatencyInfo latency_info = CreateLatencyInfo(web_event);
   if (ShouldRouteEvents()) {
@@ -1468,8 +1507,9 @@ void CefRenderWidgetHostViewOSR::UpdateFrameRate() {
   }
 
   // Notify the guest hosts if any.
-  for (auto guest_host_view : guest_host_views_)
+  for (auto guest_host_view : guest_host_views_) {
     guest_host_view->UpdateFrameRate();
+  }
 }
 
 gfx::Size CefRenderWidgetHostViewOSR::SizeInPixels() {
@@ -1529,8 +1569,9 @@ void CefRenderWidgetHostViewOSR::OnPaint(const gfx::Rect& damage_rect,
     DCHECK_GT(cached_scale_factor_, 0);
     gfx::Size expected_size =
         gfx::ScaleToCeiledSize(GetViewBounds().size(), cached_scale_factor_);
-    if (pixel_size == expected_size)
+    if (pixel_size == expected_size) {
       ReleaseResizeHold();
+    }
   }
 }
 
@@ -1539,8 +1580,9 @@ ui::Layer* CefRenderWidgetHostViewOSR::GetRootLayer() const {
 }
 
 ui::TextInputType CefRenderWidgetHostViewOSR::GetTextInputType() {
-  if (text_input_manager_ && text_input_manager_->GetTextInputState())
+  if (text_input_manager_ && text_input_manager_->GetTextInputState()) {
     return text_input_manager_->GetTextInputState()->type;
+  }
 
   return ui::TEXT_INPUT_TYPE_NONE;
 }
@@ -1556,8 +1598,9 @@ void CefRenderWidgetHostViewOSR::SetFrameRate() {
   CHECK(browser);
 
   // Only set the frame rate one time.
-  if (frame_rate_threshold_us_ != 0)
+  if (frame_rate_threshold_us_ != 0) {
     return;
+  }
 
   int frame_rate =
       osr_util::ClampFrameRate(browser->settings().windowless_frame_rate);
@@ -1590,8 +1633,9 @@ bool CefRenderWidgetHostViewOSR::SetScreenInfo() {
   // Notify the guest hosts if any.
   for (auto guest_host_view : guest_host_views_) {
     content::RenderWidgetHostImpl* rwhi = guest_host_view->render_widget_host();
-    if (!rwhi)
+    if (!rwhi) {
       continue;
+    }
     auto guest_view_osr =
         static_cast<CefRenderWidgetHostViewOSR*>(rwhi->GetView());
     if (guest_view_osr) {
@@ -1607,12 +1651,14 @@ bool CefRenderWidgetHostViewOSR::SetViewBounds() {
   DCHECK(!hold_resize_);
 
   // Popup bounds are set in InitAsPopup.
-  if (IsPopupWidget())
+  if (IsPopupWidget()) {
     return false;
+  }
 
   const gfx::Rect& new_bounds = ::GetViewBounds(browser_impl_.get());
-  if (new_bounds == current_view_bounds_)
+  if (new_bounds == current_view_bounds_) {
     return false;
+  }
 
   current_view_bounds_ = new_bounds;
   return true;
@@ -1621,8 +1667,9 @@ bool CefRenderWidgetHostViewOSR::SetViewBounds() {
 bool CefRenderWidgetHostViewOSR::SetRootLayerSize(bool force) {
   const bool screen_info_changed = SetScreenInfo();
   const bool view_bounds_changed = SetViewBounds();
-  if (!force && !screen_info_changed && !view_bounds_changed)
+  if (!force && !screen_info_changed && !view_bounds_changed) {
     return false;
+  }
 
   GetRootLayer()->SetBounds(gfx::Rect(GetViewBounds().size()));
 
@@ -1667,8 +1714,9 @@ void CefRenderWidgetHostViewOSR::ReleaseResizeHold() {
 }
 
 void CefRenderWidgetHostViewOSR::CancelWidget() {
-  if (render_widget_host_)
+  if (render_widget_host_) {
     render_widget_host_->LostCapture();
+  }
 
   Hide();
 
@@ -1739,8 +1787,9 @@ void CefRenderWidgetHostViewOSR::InvalidateInternal(
 
 void CefRenderWidgetHostViewOSR::RequestImeCompositionUpdate(
     bool start_monitoring) {
-  if (!render_widget_host_)
+  if (!render_widget_host_) {
     return;
+  }
   render_widget_host_->RequestCompositionUpdates(false, start_monitoring);
 }
 
@@ -1771,8 +1820,9 @@ viz::FrameSinkId CefRenderWidgetHostViewOSR::AllocateFrameSinkId() {
 
 void CefRenderWidgetHostViewOSR::UpdateBackgroundColorFromRenderer(
     SkColor color) {
-  if (color == background_color_)
+  if (color == background_color_) {
     return;
+  }
   background_color_ = color;
 
   bool opaque = SkColorGetA(color) == SK_AlphaOPAQUE;
diff --git a/libcef/browser/osr/render_widget_host_view_osr.h b/libcef/browser/osr/render_widget_host_view_osr.h
index 21d67dc34..698408dc5 100644
--- a/libcef/browser/osr/render_widget_host_view_osr.h
+++ b/libcef/browser/osr/render_widget_host_view_osr.h
@@ -273,8 +273,9 @@ class CefRenderWidgetHostViewOSR
   }
 
   void set_popup_host_view(CefRenderWidgetHostViewOSR* popup_view) {
-    if (popup_view != popup_host_view_)
+    if (popup_view != popup_host_view_) {
       forward_touch_to_popup_ = false;
+    }
     popup_host_view_ = popup_view;
   }
   void set_child_host_view(CefRenderWidgetHostViewOSR* popup_view) {
diff --git a/libcef/browser/osr/software_output_device_proxy.cc b/libcef/browser/osr/software_output_device_proxy.cc
index 883bb5783..90ccdd077 100644
--- a/libcef/browser/osr/software_output_device_proxy.cc
+++ b/libcef/browser/osr/software_output_device_proxy.cc
@@ -52,8 +52,9 @@ void SoftwareOutputDeviceProxy::Resize(const gfx::Size& viewport_pixel_size,
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(!in_paint_);
 
-  if (viewport_pixel_size_ == viewport_pixel_size)
+  if (viewport_pixel_size_ == viewport_pixel_size) {
     return;
+  }
 
   viewport_pixel_size_ = viewport_pixel_size;
 
@@ -119,11 +120,13 @@ void SoftwareOutputDeviceProxy::EndPaint() {
 
   gfx::Rect intersected_damage_rect = damage_rect_;
   intersected_damage_rect.Intersect(gfx::Rect(viewport_pixel_size_));
-  if (intersected_damage_rect.IsEmpty())
+  if (intersected_damage_rect.IsEmpty()) {
     return;
+  }
 
-  if (!canvas_)
+  if (!canvas_) {
     return;
+  }
 
   layered_window_updater_->Draw(
       damage_rect_, base::BindOnce(&SoftwareOutputDeviceProxy::DrawAck,
diff --git a/libcef/browser/osr/touch_handle_drawable_osr.cc b/libcef/browser/osr/touch_handle_drawable_osr.cc
index d12f568fd..96b0e8d52 100644
--- a/libcef/browser/osr/touch_handle_drawable_osr.cc
+++ b/libcef/browser/osr/touch_handle_drawable_osr.cc
@@ -33,8 +33,9 @@ CefTouchHandleDrawableOSR::CefTouchHandleDrawableOSR(
     : rwhv_(rwhv), id_(counter_++) {}
 
 void CefTouchHandleDrawableOSR::SetEnabled(bool enabled) {
-  if (enabled == enabled_)
+  if (enabled == enabled_) {
     return;
+  }
 
   enabled_ = enabled;
 
@@ -49,8 +50,9 @@ void CefTouchHandleDrawableOSR::SetOrientation(
     ui::TouchHandleOrientation orientation,
     bool mirror_vertical,
     bool mirror_horizontal) {
-  if (orientation == orientation_)
+  if (orientation == orientation_) {
     return;
+  }
 
   orientation_ = orientation;
 
@@ -80,8 +82,9 @@ void CefTouchHandleDrawableOSR::SetOrientation(
 }
 
 void CefTouchHandleDrawableOSR::SetOrigin(const gfx::PointF& position) {
-  if (position == origin_position_)
+  if (position == origin_position_) {
     return;
+  }
 
   origin_position_ = position;
 
@@ -94,8 +97,9 @@ void CefTouchHandleDrawableOSR::SetOrigin(const gfx::PointF& position) {
 }
 
 void CefTouchHandleDrawableOSR::SetAlpha(float alpha) {
-  if (alpha == alpha_)
+  if (alpha == alpha_) {
     return;
+  }
 
   alpha_ = alpha;
 
diff --git a/libcef/browser/osr/touch_selection_controller_client_osr.cc b/libcef/browser/osr/touch_selection_controller_client_osr.cc
index 552331b81..06fb6a1b8 100644
--- a/libcef/browser/osr/touch_selection_controller_client_osr.cc
+++ b/libcef/browser/osr/touch_selection_controller_client_osr.cc
@@ -108,8 +108,9 @@ CefTouchSelectionControllerClientOSR::CefTouchSelectionControllerClientOSR(
 }
 
 CefTouchSelectionControllerClientOSR::~CefTouchSelectionControllerClientOSR() {
-  for (auto& observer : observers_)
+  for (auto& observer : observers_) {
     observer.OnManagerWillDestroy(this);
+  }
 }
 
 void CefTouchSelectionControllerClientOSR::CloseQuickMenuAndHideHandles() {
@@ -158,8 +159,9 @@ bool CefTouchSelectionControllerClientOSR::HandleContextMenu(
   const bool from_touch = params.source_type == ui::MENU_SOURCE_LONG_PRESS ||
                           params.source_type == ui::MENU_SOURCE_LONG_TAP ||
                           params.source_type == ui::MENU_SOURCE_TOUCH;
-  if (from_touch && !params.selection_text.empty())
+  if (from_touch && !params.selection_text.empty()) {
     return true;
+  }
 
   rwhv_->selection_controller()->HideAndDisallowShowingAutomatically();
   return false;
@@ -234,8 +236,9 @@ bool CefTouchSelectionControllerClientOSR::IsQuickMenuAvailable() const {
 }
 
 void CefTouchSelectionControllerClientOSR::CloseQuickMenu() {
-  if (!quick_menu_running_)
+  if (!quick_menu_running_) {
     return;
+  }
 
   quick_menu_running_ = false;
 
@@ -256,8 +259,9 @@ void CefTouchSelectionControllerClientOSR::ShowQuickMenu() {
     auto client_bounds = gfx::RectF(rwhv_->GetViewBounds());
     origin.SetToMax(client_bounds.origin());
     bottom_right.SetToMin(client_bounds.bottom_right());
-    if (origin.x() > bottom_right.x() || origin.y() > bottom_right.y())
+    if (origin.x() > bottom_right.x() || origin.y() > bottom_right.y()) {
       return;
+    }
 
     gfx::Vector2dF diagonal = bottom_right - origin;
     gfx::SizeF size(diagonal.x(), diagonal.y());
diff --git a/libcef/browser/osr/video_consumer_osr.cc b/libcef/browser/osr/video_consumer_osr.cc
index c28e66bc6..ee0e0c986 100644
--- a/libcef/browser/osr/video_consumer_osr.cc
+++ b/libcef/browser/osr/video_consumer_osr.cc
@@ -56,8 +56,9 @@ void CefVideoConsumerOSR::SetFrameRate(base::TimeDelta frame_rate) {
 }
 
 void CefVideoConsumerOSR::SizeChanged(const gfx::Size& size_in_pixels) {
-  if (size_in_pixels_ == size_in_pixels)
+  if (size_in_pixels_ == size_in_pixels) {
     return;
+  }
   size_in_pixels_ = size_in_pixels;
 
   // Capture resolution will be held constant.
diff --git a/libcef/browser/osr/web_contents_view_osr.cc b/libcef/browser/osr/web_contents_view_osr.cc
index e6c878e86..6488f5385 100644
--- a/libcef/browser/osr/web_contents_view_osr.cc
+++ b/libcef/browser/osr/web_contents_view_osr.cc
@@ -38,8 +38,9 @@ void CefWebContentsViewOSR::RenderViewCreated() {
     auto host = web_contents_->GetRenderViewHost();
     CefRenderWidgetHostViewOSR* view =
         static_cast<CefRenderWidgetHostViewOSR*>(host->GetWidget()->GetView());
-    if (view)
+    if (view) {
       view->InstallTransparency();
+    }
   }
 }
 
@@ -74,8 +75,9 @@ void CefWebContentsViewOSR::GotFocus(
   if (web_contents_) {
     content::WebContentsImpl* web_contents_impl =
         static_cast<content::WebContentsImpl*>(web_contents_);
-    if (web_contents_impl)
+    if (web_contents_impl) {
       web_contents_impl->NotifyWebContentsFocused(render_widget_host);
+    }
   }
 }
 
@@ -84,14 +86,16 @@ void CefWebContentsViewOSR::LostFocus(
   if (web_contents_) {
     content::WebContentsImpl* web_contents_impl =
         static_cast<content::WebContentsImpl*>(web_contents_);
-    if (web_contents_impl)
+    if (web_contents_impl) {
       web_contents_impl->NotifyWebContentsLostFocus(render_widget_host);
+    }
   }
 }
 
 void CefWebContentsViewOSR::TakeFocus(bool reverse) {
-  if (web_contents_->GetDelegate())
+  if (web_contents_->GetDelegate()) {
     web_contents_->GetDelegate()->TakeFocus(web_contents_, reverse);
+  }
 }
 
 void CefWebContentsViewOSR::FullscreenStateChanged(bool is_fullscreen) {}
@@ -188,8 +192,9 @@ void CefWebContentsViewOSR::StartDragging(
 void CefWebContentsViewOSR::UpdateDragCursor(
     ui::mojom::DragOperation operation) {
   CefRefPtr<AlloyBrowserHostImpl> browser = GetBrowser();
-  if (browser.get())
+  if (browser.get()) {
     browser->UpdateDragCursor(operation);
+  }
 }
 
 CefRenderWidgetHostViewOSR* CefWebContentsViewOSR::GetView() const {
@@ -202,8 +207,9 @@ CefRenderWidgetHostViewOSR* CefWebContentsViewOSR::GetView() const {
 
 AlloyBrowserHostImpl* CefWebContentsViewOSR::GetBrowser() const {
   CefRenderWidgetHostViewOSR* view = GetView();
-  if (view)
+  if (view) {
     return view->browser_impl().get();
+  }
   return nullptr;
 }
 
diff --git a/libcef/browser/prefs/pref_helper.cc b/libcef/browser/prefs/pref_helper.cc
index 18eed8cf9..6857c6853 100644
--- a/libcef/browser/prefs/pref_helper.cc
+++ b/libcef/browser/prefs/pref_helper.cc
@@ -48,8 +48,9 @@ bool HasPreference(PrefService* pref_service, const CefString& name) {
 CefRefPtr<CefValue> GetPreference(PrefService* pref_service,
                                   const CefString& name) {
   const PrefService::Preference* pref = pref_service->FindPreference(name);
-  if (!pref)
+  if (!pref) {
     return nullptr;
+  }
   return new CefValueImpl(new base::Value(pref->GetValue()->Clone()));
 }
 
diff --git a/libcef/browser/prefs/pref_store.cc b/libcef/browser/prefs/pref_store.cc
index 2a69b4d92..0fb170bf2 100644
--- a/libcef/browser/prefs/pref_store.cc
+++ b/libcef/browser/prefs/pref_store.cc
@@ -61,8 +61,9 @@ void CefPrefStore::SetValue(const std::string& key,
 void CefPrefStore::SetValueSilently(const std::string& key,
                                     base::Value value,
                                     uint32_t flags) {
-  if (prefs_.SetValue(key, std::move(value)))
+  if (prefs_.SetValue(key, std::move(value))) {
     committed_ = false;
+  }
 }
 
 void CefPrefStore::RemoveValuesByPrefixSilently(const std::string& prefix) {
@@ -93,10 +94,11 @@ PersistentPrefStore::PrefReadError CefPrefStore::ReadPrefs() {
 void CefPrefStore::ReadPrefsAsync(ReadErrorDelegate* error_delegate) {
   DCHECK(!pending_async_read_);
   error_delegate_.reset(error_delegate);
-  if (block_async_read_)
+  if (block_async_read_) {
     pending_async_read_ = true;
-  else
+  } else {
     NotifyInitializationCompleted();
+  }
 }
 
 void CefPrefStore::CommitPendingWrite(
@@ -116,22 +118,26 @@ void CefPrefStore::SetInitializationCompleted() {
 }
 
 void CefPrefStore::NotifyPrefValueChanged(const std::string& key) {
-  for (Observer& observer : observers_)
+  for (Observer& observer : observers_) {
     observer.OnPrefValueChanged(key);
+  }
 }
 
 void CefPrefStore::NotifyInitializationCompleted() {
   DCHECK(!init_complete_);
   init_complete_ = true;
-  if (read_success_ && read_error_ != PREF_READ_ERROR_NONE && error_delegate_)
+  if (read_success_ && read_error_ != PREF_READ_ERROR_NONE && error_delegate_) {
     error_delegate_->OnError(read_error_);
-  for (Observer& observer : observers_)
+  }
+  for (Observer& observer : observers_) {
     observer.OnInitializationCompleted(read_success_);
+  }
 }
 
 void CefPrefStore::ReportValueChanged(const std::string& key, uint32_t flags) {
-  for (Observer& observer : observers_)
+  for (Observer& observer : observers_) {
     observer.OnPrefValueChanged(key);
+  }
 }
 
 void CefPrefStore::SetString(const std::string& key, const std::string& value) {
@@ -148,8 +154,9 @@ void CefPrefStore::SetBoolean(const std::string& key, bool value) {
 
 bool CefPrefStore::GetString(const std::string& key, std::string* value) const {
   const base::Value* stored_value;
-  if (!prefs_.GetValue(key, &stored_value) || !stored_value)
+  if (!prefs_.GetValue(key, &stored_value) || !stored_value) {
     return false;
+  }
 
   if (value && stored_value->is_string()) {
     *value = stored_value->GetString();
@@ -160,8 +167,9 @@ bool CefPrefStore::GetString(const std::string& key, std::string* value) const {
 
 bool CefPrefStore::GetInteger(const std::string& key, int* value) const {
   const base::Value* stored_value;
-  if (!prefs_.GetValue(key, &stored_value) || !stored_value)
+  if (!prefs_.GetValue(key, &stored_value) || !stored_value) {
     return false;
+  }
 
   if (value && stored_value->is_int()) {
     *value = stored_value->GetInt();
@@ -172,8 +180,9 @@ bool CefPrefStore::GetInteger(const std::string& key, int* value) const {
 
 bool CefPrefStore::GetBoolean(const std::string& key, bool* value) const {
   const base::Value* stored_value;
-  if (!prefs_.GetValue(key, &stored_value) || !stored_value)
+  if (!prefs_.GetValue(key, &stored_value) || !stored_value) {
     return false;
+  }
 
   if (value && stored_value->is_bool()) {
     *value = stored_value->GetBool();
@@ -185,8 +194,9 @@ bool CefPrefStore::GetBoolean(const std::string& key, bool* value) const {
 void CefPrefStore::SetBlockAsyncRead(bool block_async_read) {
   DCHECK(!init_complete_);
   block_async_read_ = block_async_read;
-  if (pending_async_read_ && !block_async_read_)
+  if (pending_async_read_ && !block_async_read_) {
     NotifyInitializationCompleted();
+  }
 }
 
 void CefPrefStore::set_read_only(bool read_only) {
diff --git a/libcef/browser/prefs/renderer_prefs.cc b/libcef/browser/prefs/renderer_prefs.cc
index 011ad594c..2411c4859 100644
--- a/libcef/browser/prefs/renderer_prefs.cc
+++ b/libcef/browser/prefs/renderer_prefs.cc
@@ -82,12 +82,15 @@ void SetChromePrefs(Profile* profile, blink::web_pref::WebPreferences& web) {
   web.dom_paste_enabled = prefs->GetBoolean(prefs::kWebKitDomPasteEnabled);
   web.tabs_to_links = prefs->GetBoolean(prefs::kWebkitTabsToLinks);
 
-  if (!prefs->GetBoolean(prefs::kWebKitJavascriptEnabled))
+  if (!prefs->GetBoolean(prefs::kWebKitJavascriptEnabled)) {
     web.javascript_enabled = false;
-  if (!prefs->GetBoolean(prefs::kWebKitWebSecurityEnabled))
+  }
+  if (!prefs->GetBoolean(prefs::kWebKitWebSecurityEnabled)) {
     web.web_security_enabled = false;
-  if (!prefs->GetBoolean(prefs::kWebKitPluginsEnabled))
+  }
+  if (!prefs->GetBoolean(prefs::kWebKitPluginsEnabled)) {
     web.plugins_enabled = false;
+  }
   web.loads_images_automatically =
       prefs->GetBoolean(prefs::kWebKitLoadsImagesAutomatically);
 
@@ -143,14 +146,16 @@ void SetChromePrefs(Profile* profile, blink::web_pref::WebPreferences& web) {
 void SetExtensionPrefs(content::WebContents* web_contents,
                        content::RenderViewHost* rvh,
                        blink::web_pref::WebPreferences& web) {
-  if (!extensions::ExtensionsEnabled())
+  if (!extensions::ExtensionsEnabled()) {
     return;
+  }
 
   const extensions::ExtensionRegistry* registry =
       extensions::ExtensionRegistry::Get(
           rvh->GetProcess()->GetBrowserContext());
-  if (!registry)
+  if (!registry) {
     return;
+  }
 
   // Note: it's not possible for kExtensionsScheme to change during the lifetime
   // of the process.
@@ -161,8 +166,9 @@ void SetExtensionPrefs(content::WebContents* web_contents,
   // would get the wrong preferences.
   const GURL& site_url =
       web_contents->GetPrimaryMainFrame()->GetSiteInstance()->GetSiteURL();
-  if (!site_url.SchemeIs(extensions::kExtensionScheme))
+  if (!site_url.SchemeIs(extensions::kExtensionScheme)) {
     return;
+  }
 
   const extensions::Extension* extension =
       registry->enabled_extensions().GetByID(site_url.host());
@@ -236,12 +242,15 @@ void SetCommandLinePrefDefaults(CommandLinePrefStore* prefs) {
               command_line->GetSwitchValueASCII(switches::kDefaultEncoding));
   }
 
-  if (command_line->HasSwitch(switches::kDisableJavascriptDomPaste))
+  if (command_line->HasSwitch(switches::kDisableJavascriptDomPaste)) {
     SetBool(prefs, prefs::kWebKitDomPasteEnabled, false);
-  if (command_line->HasSwitch(switches::kDisableImageLoading))
+  }
+  if (command_line->HasSwitch(switches::kDisableImageLoading)) {
     SetBool(prefs, prefs::kWebKitLoadsImagesAutomatically, false);
-  if (command_line->HasSwitch(switches::kDisableTabToLinks))
+  }
+  if (command_line->HasSwitch(switches::kDisableTabToLinks)) {
     SetBool(prefs, prefs::kWebkitTabsToLinks, false);
+  }
 }
 
 void SetDefaultPrefs(blink::web_pref::WebPreferences& web) {
@@ -297,17 +306,22 @@ void SetCefPrefs(const CefBrowserSettings& cef,
         CefString(&cef.fantasy_font_family);
   }
 
-  if (cef.default_font_size > 0)
+  if (cef.default_font_size > 0) {
     web.default_font_size = cef.default_font_size;
-  if (cef.default_fixed_font_size > 0)
+  }
+  if (cef.default_fixed_font_size > 0) {
     web.default_fixed_font_size = cef.default_fixed_font_size;
-  if (cef.minimum_font_size > 0)
+  }
+  if (cef.minimum_font_size > 0) {
     web.minimum_font_size = cef.minimum_font_size;
-  if (cef.minimum_logical_font_size > 0)
+  }
+  if (cef.minimum_logical_font_size > 0) {
     web.minimum_logical_font_size = cef.minimum_logical_font_size;
+  }
 
-  if (cef.default_encoding.length > 0)
+  if (cef.default_encoding.length > 0) {
     web.default_encoding = CefString(&cef.default_encoding);
+  }
 
   SET_STATE(cef.remote_fonts, web.remote_fonts_enabled);
   SET_STATE(cef.javascript, web.javascript_enabled);
diff --git a/libcef/browser/print_settings_impl.cc b/libcef/browser/print_settings_impl.cc
index af7d76d01..b789c8ff1 100644
--- a/libcef/browser/print_settings_impl.cc
+++ b/libcef/browser/print_settings_impl.cc
@@ -90,8 +90,9 @@ size_t CefPrintSettingsImpl::GetPageRangesCount() {
 
 void CefPrintSettingsImpl::GetPageRanges(PageRangeList& ranges) {
   CEF_VALUE_VERIFY_RETURN_VOID(false);
-  if (!ranges.empty())
+  if (!ranges.empty()) {
     ranges.clear();
+  }
   const printing::PageRanges& page_ranges = const_value().ranges();
   printing::PageRanges::const_iterator it = page_ranges.begin();
   for (; it != page_ranges.end(); ++it) {
diff --git a/libcef/browser/printing/print_dialog_linux.cc b/libcef/browser/printing/print_dialog_linux.cc
index ff535de42..26f760aff 100644
--- a/libcef/browser/printing/print_dialog_linux.cc
+++ b/libcef/browser/printing/print_dialog_linux.cc
@@ -35,8 +35,9 @@ namespace {
 CefRefPtr<CefBrowserHostBase> GetBrowserForContext(
     printing::PrintingContextLinux* context) {
   // The print preview dialog won't have a valid child ID.
-  if (!frame_util::IsValidChildId(context->render_process_id()))
+  if (!frame_util::IsValidChildId(context->render_process_id())) {
     return nullptr;
+  }
 
   return extensions::GetOwnerBrowserForGlobalId(
       frame_util::MakeGlobalId(context->render_process_id(),
@@ -264,8 +265,9 @@ void CefPrintDialogLinux::PrintDocument(
                     base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
     success = metafile.SaveTo(&file);
     file.Close();
-    if (!success)
+    if (!success) {
       base::DeleteFile(path_to_pdf_);
+    }
   }
 
   if (!success) {
diff --git a/libcef/browser/printing/print_util.cc b/libcef/browser/printing/print_util.cc
index 9054e982d..c6a1527cd 100644
--- a/libcef/browser/printing/print_util.cc
+++ b/libcef/browser/printing/print_util.cc
@@ -69,10 +69,12 @@ void PrintToPDF(content::WebContents* web_contents,
   // Defaults to no header/footer.
   absl::optional<std::string> header_template, footer_template;
   if (display_header_footer) {
-    if (settings.header_template.length > 0)
+    if (settings.header_template.length > 0) {
       header_template = CefString(&settings.header_template);
-    if (settings.footer_template.length > 0)
+    }
+    if (settings.footer_template.length > 0) {
       footer_template = CefString(&settings.footer_template);
+    }
   }
 
   // Defaults to 1.0.
@@ -96,14 +98,18 @@ void PrintToPDF(content::WebContents* web_contents,
     margin_left = 0;
     margin_right = 0;
   } else if (settings.margin_type == PDF_PRINT_MARGIN_CUSTOM) {
-    if (settings.margin_top >= 0)
+    if (settings.margin_top >= 0) {
       margin_top = settings.margin_top;
-    if (settings.margin_bottom >= 0)
+    }
+    if (settings.margin_bottom >= 0) {
       margin_bottom = settings.margin_bottom;
-    if (settings.margin_left >= 0)
+    }
+    if (settings.margin_left >= 0) {
       margin_left = settings.margin_left;
-    if (settings.margin_right >= 0)
+    }
+    if (settings.margin_right >= 0) {
       margin_right = settings.margin_right;
+    }
   }
 
   absl::variant<printing::mojom::PrintPagesParamsPtr, std::string>
diff --git a/libcef/browser/request_context_handler_map.cc b/libcef/browser/request_context_handler_map.cc
index 31c027dc2..eca2290e0 100644
--- a/libcef/browser/request_context_handler_map.cc
+++ b/libcef/browser/request_context_handler_map.cc
@@ -23,8 +23,9 @@ void CefRequestContextHandlerMap::RemoveHandler(
   DCHECK(frame_util::IsValidGlobalId(global_id));
 
   auto it1 = render_id_handler_map_.find(global_id);
-  if (it1 != render_id_handler_map_.end())
+  if (it1 != render_id_handler_map_.end()) {
     render_id_handler_map_.erase(it1);
+  }
 }
 
 CefRefPtr<CefRequestContextHandler> CefRequestContextHandlerMap::GetHandler(
@@ -32,15 +33,17 @@ CefRefPtr<CefRequestContextHandler> CefRequestContextHandlerMap::GetHandler(
     bool require_frame_match) const {
   if (frame_util::IsValidGlobalId(global_id)) {
     const auto it1 = render_id_handler_map_.find(global_id);
-    if (it1 != render_id_handler_map_.end())
+    if (it1 != render_id_handler_map_.end()) {
       return it1->second;
+    }
   }
 
   if (frame_util::IsValidChildId(global_id.child_id) && !require_frame_match) {
     // Choose an arbitrary handler for the same process.
     for (auto& kv : render_id_handler_map_) {
-      if (kv.first.child_id == global_id.child_id)
+      if (kv.first.child_id == global_id.child_id) {
         return kv.second;
+      }
     }
   }
 
diff --git a/libcef/browser/request_context_impl.cc b/libcef/browser/request_context_impl.cc
index 1dcb60209..77aa44b75 100644
--- a/libcef/browser/request_context_impl.cc
+++ b/libcef/browser/request_context_impl.cc
@@ -130,8 +130,9 @@ CefRefPtr<CefRequestContext> CefRequestContext::CreateContext(
     return nullptr;
   }
 
-  if (!other.get())
+  if (!other.get()) {
     return nullptr;
+  }
 
   CefRequestContextImpl::Config config;
   config.other = static_cast<CefRequestContextImpl*>(other.get());
@@ -217,8 +218,9 @@ void CefRequestContextImpl::ExecuteWhenBrowserContextInitialized(
 void CefRequestContextImpl::GetBrowserContext(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     BrowserContextCallback callback) {
-  if (!task_runner.get())
+  if (!task_runner.get()) {
     task_runner = CefTaskRunnerImpl::GetCurrentTaskRunner();
+  }
 
   ExecuteWhenBrowserContextInitialized(base::BindOnce(
       [](CefRefPtr<CefRequestContextImpl> context,
@@ -246,12 +248,14 @@ void CefRequestContextImpl::GetBrowserContext(
 bool CefRequestContextImpl::IsSame(CefRefPtr<CefRequestContext> other) {
   CefRequestContextImpl* other_impl =
       static_cast<CefRequestContextImpl*>(other.get());
-  if (!other_impl)
+  if (!other_impl) {
     return false;
+  }
 
   // Compare whether both are the global context.
-  if (config_.is_global && other_impl->config_.is_global)
+  if (config_.is_global && other_impl->config_.is_global) {
     return true;
+  }
 
   // Compare CefBrowserContext pointers if one has been associated.
   if (browser_context() && other_impl->browser_context()) {
@@ -267,11 +271,13 @@ bool CefRequestContextImpl::IsSame(CefRefPtr<CefRequestContext> other) {
 bool CefRequestContextImpl::IsSharingWith(CefRefPtr<CefRequestContext> other) {
   CefRequestContextImpl* other_impl =
       static_cast<CefRequestContextImpl*>(other.get());
-  if (!other_impl)
+  if (!other_impl) {
     return false;
+  }
 
-  if (IsSame(other))
+  if (IsSame(other)) {
     return true;
+  }
 
   CefRefPtr<CefRequestContext> pending_other = config_.other;
   if (pending_other.get()) {
@@ -344,16 +350,18 @@ bool CefRequestContextImpl::ClearSchemeHandlerFactories() {
       content::GetUIThreadTaskRunner({}),
       base::BindOnce([](CefBrowserContext::Getter browser_context_getter) {
         auto browser_context = browser_context_getter.Run();
-        if (browser_context)
+        if (browser_context) {
           browser_context->ClearSchemeHandlerFactories();
+        }
       }));
 
   return true;
 }
 
 bool CefRequestContextImpl::HasPreference(const CefString& name) {
-  if (!VerifyBrowserContext())
+  if (!VerifyBrowserContext()) {
     return false;
+  }
 
   PrefService* pref_service = browser_context()->AsProfile()->GetPrefs();
   return pref_helper::HasPreference(pref_service, name);
@@ -361,8 +369,9 @@ bool CefRequestContextImpl::HasPreference(const CefString& name) {
 
 CefRefPtr<CefValue> CefRequestContextImpl::GetPreference(
     const CefString& name) {
-  if (!VerifyBrowserContext())
+  if (!VerifyBrowserContext()) {
     return nullptr;
+  }
 
   PrefService* pref_service = browser_context()->AsProfile()->GetPrefs();
   return pref_helper::GetPreference(pref_service, name);
@@ -370,16 +379,18 @@ CefRefPtr<CefValue> CefRequestContextImpl::GetPreference(
 
 CefRefPtr<CefDictionaryValue> CefRequestContextImpl::GetAllPreferences(
     bool include_defaults) {
-  if (!VerifyBrowserContext())
+  if (!VerifyBrowserContext()) {
     return nullptr;
+  }
 
   PrefService* pref_service = browser_context()->AsProfile()->GetPrefs();
   return pref_helper::GetAllPreferences(pref_service, include_defaults);
 }
 
 bool CefRequestContextImpl::CanSetPreference(const CefString& name) {
-  if (!VerifyBrowserContext())
+  if (!VerifyBrowserContext()) {
     return false;
+  }
 
   PrefService* pref_service = browser_context()->AsProfile()->GetPrefs();
   return pref_helper::CanSetPreference(pref_service, name);
@@ -388,8 +399,9 @@ bool CefRequestContextImpl::CanSetPreference(const CefString& name) {
 bool CefRequestContextImpl::SetPreference(const CefString& name,
                                           CefRefPtr<CefValue> value,
                                           CefString& error) {
-  if (!VerifyBrowserContext())
+  if (!VerifyBrowserContext()) {
     return false;
+  }
 
   PrefService* pref_service = browser_context()->AsProfile()->GetPrefs();
   return pref_helper::SetPreference(pref_service, name, value, error);
@@ -462,16 +474,18 @@ bool CefRequestContextImpl::GetExtensions(
     std::vector<CefString>& extension_ids) {
   extension_ids.clear();
 
-  if (!VerifyBrowserContext())
+  if (!VerifyBrowserContext()) {
     return false;
+  }
 
   return browser_context()->GetExtensions(extension_ids);
 }
 
 CefRefPtr<CefExtension> CefRequestContextImpl::GetExtension(
     const CefString& extension_id) {
-  if (!VerifyBrowserContext())
+  if (!VerifyBrowserContext()) {
     return nullptr;
+  }
 
   return browser_context()->GetExtension(extension_id);
 }
@@ -592,8 +606,9 @@ void CefRequestContextImpl::BrowserContextInitialized() {
 
 void CefRequestContextImpl::EnsureBrowserContext() {
   CEF_REQUIRE_UIT();
-  if (!browser_context())
+  if (!browser_context()) {
     Initialize();
+  }
   DCHECK(browser_context());
 }
 
@@ -601,13 +616,15 @@ void CefRequestContextImpl::ClearCertificateExceptionsInternal(
     CefRefPtr<CefCompletionCallback> callback,
     CefBrowserContext::Getter browser_context_getter) {
   auto browser_context = browser_context_getter.Run();
-  if (!browser_context)
+  if (!browser_context) {
     return;
+  }
 
   content::SSLHostStateDelegate* ssl_delegate =
       browser_context->AsBrowserContext()->GetSSLHostStateDelegate();
-  if (ssl_delegate)
+  if (ssl_delegate) {
     ssl_delegate->Clear(base::NullCallback());
+  }
 
   if (callback) {
     CEF_POST_TASK(CEF_UIT,
@@ -619,8 +636,9 @@ void CefRequestContextImpl::ClearHttpAuthCredentialsInternal(
     CefRefPtr<CefCompletionCallback> callback,
     CefBrowserContext::Getter browser_context_getter) {
   auto browser_context = browser_context_getter.Run();
-  if (!browser_context)
+  if (!browser_context) {
     return;
+  }
 
   browser_context->GetNetworkContext()->ClearHttpAuthCache(
       /*start_time=*/base::Time(), /*end_time=*/base::Time::Max(),
@@ -631,8 +649,9 @@ void CefRequestContextImpl::CloseAllConnectionsInternal(
     CefRefPtr<CefCompletionCallback> callback,
     CefBrowserContext::Getter browser_context_getter) {
   auto browser_context = browser_context_getter.Run();
-  if (!browser_context)
+  if (!browser_context) {
     return;
+  }
 
   browser_context->GetNetworkContext()->CloseAllConnections(
       base::BindOnce(&CefCompletionCallback::OnComplete, callback));
@@ -643,8 +662,9 @@ void CefRequestContextImpl::ResolveHostInternal(
     CefRefPtr<CefResolveCallback> callback,
     CefBrowserContext::Getter browser_context_getter) {
   auto browser_context = browser_context_getter.Run();
-  if (!browser_context)
+  if (!browser_context) {
     return;
+  }
 
   // |helper| will be deleted in ResolveHostHelper::OnComplete().
   ResolveHostHelper* helper = new ResolveHostHelper(callback);
diff --git a/libcef/browser/screen_util.cc b/libcef/browser/screen_util.cc
index 30bb84ba7..ac1023cdf 100644
--- a/libcef/browser/screen_util.cc
+++ b/libcef/browser/screen_util.cc
@@ -19,8 +19,9 @@ int clamp_segment_start(int start, int len, int min, int max) {
   const int end = start + len;
   const int excess = end - max;
 
-  if (excess > 0)
+  if (excess > 0) {
     start = start - excess;
+  }
 
   return start;
 }
diff --git a/libcef/browser/server_impl.cc b/libcef/browser/server_impl.cc
index ad7958024..700e8ff52 100644
--- a/libcef/browser/server_impl.cc
+++ b/libcef/browser/server_impl.cc
@@ -88,8 +88,9 @@ CefRefPtr<CefRequest> CreateRequest(const std::string& address,
   CefRefPtr<CefRequestImpl> request = new CefRequestImpl();
   request->Set((is_websocket ? "ws://" : "http://") + address + info.path,
                info.method, post_data, header_map);
-  if (!referer.empty())
+  if (!referer.empty()) {
     request->SetReferrer(referer, REFERRER_POLICY_DEFAULT);
+  }
   request->SetReadOnly(true);
   return request;
 }
@@ -109,8 +110,9 @@ class AcceptWebSocketCallback : public CefCallback {
   AcceptWebSocketCallback& operator=(const AcceptWebSocketCallback&) = delete;
 
   ~AcceptWebSocketCallback() override {
-    if (impl_)
+    if (impl_) {
       impl_->ContinueWebSocketRequest(connection_id_, request_info_, false);
+    }
   }
 
   void Continue() override {
@@ -119,8 +121,9 @@ class AcceptWebSocketCallback : public CefCallback {
                     base::BindOnce(&AcceptWebSocketCallback::Continue, this));
       return;
     }
-    if (!impl_)
+    if (!impl_) {
       return;
+    }
     impl_->ContinueWebSocketRequest(connection_id_, request_info_, true);
     impl_ = nullptr;
   }
@@ -131,8 +134,9 @@ class AcceptWebSocketCallback : public CefCallback {
                     base::BindOnce(&AcceptWebSocketCallback::Cancel, this));
       return;
     }
-    if (!impl_)
+    if (!impl_) {
       return;
+    }
     impl_->ContinueWebSocketRequest(connection_id_, request_info_, false);
     impl_ = nullptr;
   }
@@ -182,8 +186,9 @@ void CefServerImpl::Start(const std::string& address,
 }
 
 CefRefPtr<CefTaskRunner> CefServerImpl::GetTaskRunner() {
-  if (task_runner_)
+  if (task_runner_) {
     return new CefTaskRunnerImpl(task_runner_);
+  }
   return nullptr;
 }
 
@@ -226,12 +231,14 @@ void CefServerImpl::SendHttp404Response(int connection_id) {
     return;
   }
 
-  if (!ValidateServer())
+  if (!ValidateServer()) {
     return;
+  }
 
   ConnectionInfo* info = GetConnectionInfo(connection_id);
-  if (!info)
+  if (!info) {
     return;
+  }
 
   if (info->is_websocket) {
     LOG(ERROR) << "Invalid attempt to send HTTP response for connection_id "
@@ -251,12 +258,14 @@ void CefServerImpl::SendHttp500Response(int connection_id,
     return;
   }
 
-  if (!ValidateServer())
+  if (!ValidateServer()) {
     return;
+  }
 
   ConnectionInfo* info = GetConnectionInfo(connection_id);
-  if (!info)
+  if (!info) {
     return;
+  }
 
   if (info->is_websocket) {
     LOG(ERROR) << "Invalid attempt to send HTTP response for connection_id "
@@ -280,12 +289,14 @@ void CefServerImpl::SendHttpResponse(int connection_id,
     return;
   }
 
-  if (!ValidateServer())
+  if (!ValidateServer()) {
     return;
+  }
 
   ConnectionInfo* info = GetConnectionInfo(connection_id);
-  if (!info)
+  if (!info) {
     return;
+  }
 
   if (info->is_websocket) {
     LOG(ERROR) << "Invalid attempt to send HTTP response for connection_id "
@@ -297,8 +308,9 @@ void CefServerImpl::SendHttpResponse(int connection_id,
       static_cast<net::HttpStatusCode>(response_code));
 
   HeaderMap::const_iterator it = extra_headers.begin();
-  for (; it != extra_headers.end(); ++it)
+  for (; it != extra_headers.end(); ++it) {
     response.AddHeader(it->first, it->second);
+  }
 
   response.AddHeader(net::HttpRequestHeaders::kContentType, content_type);
   if (content_length >= 0) {
@@ -316,8 +328,9 @@ void CefServerImpl::SendHttpResponse(int connection_id,
 void CefServerImpl::SendRawData(int connection_id,
                                 const void* data,
                                 size_t data_size) {
-  if (!data || data_size == 0)
+  if (!data || data_size == 0) {
     return;
+  }
   SendRawDataInternal(connection_id, CreateUniqueString(data, data_size));
 }
 
@@ -336,8 +349,9 @@ void CefServerImpl::CloseConnection(int connection_id) {
 void CefServerImpl::SendWebSocketMessage(int connection_id,
                                          const void* data,
                                          size_t data_size) {
-  if (!data || data_size == 0)
+  if (!data || data_size == 0) {
     return;
+  }
   SendWebSocketMessageInternal(connection_id,
                                CreateUniqueString(data, data_size));
 }
@@ -352,18 +366,21 @@ void CefServerImpl::ContinueWebSocketRequest(
     return;
   }
 
-  if (!ValidateServer())
+  if (!ValidateServer()) {
     return;
+  }
 
   ConnectionInfo* info = GetConnectionInfo(connection_id);
   DCHECK(info);
-  if (!info)
+  if (!info) {
     return;
+  }
 
   DCHECK(info->is_websocket);
   DCHECK(info->is_websocket_pending);
-  if (!info->is_websocket || !info->is_websocket_pending)
+  if (!info->is_websocket || !info->is_websocket_pending) {
     return;
+  }
 
   info->is_websocket_pending = false;
 
@@ -387,12 +404,14 @@ void CefServerImpl::SendHttp200ResponseInternal(
     return;
   }
 
-  if (!ValidateServer())
+  if (!ValidateServer()) {
     return;
+  }
 
   ConnectionInfo* info = GetConnectionInfo(connection_id);
-  if (!info)
+  if (!info) {
     return;
+  }
 
   if (info->is_websocket) {
     LOG(ERROR) << "Invalid attempt to send HTTP response for connection_id "
@@ -413,11 +432,13 @@ void CefServerImpl::SendRawDataInternal(int connection_id,
     return;
   }
 
-  if (!ValidateServer())
+  if (!ValidateServer()) {
     return;
+  }
 
-  if (!GetConnectionInfo(connection_id))
+  if (!GetConnectionInfo(connection_id)) {
     return;
+  }
 
   server_->SendRaw(connection_id, *data, MISSING_TRAFFIC_ANNOTATION);
 }
@@ -432,12 +453,14 @@ void CefServerImpl::SendWebSocketMessageInternal(
     return;
   }
 
-  if (!ValidateServer())
+  if (!ValidateServer()) {
     return;
+  }
 
   ConnectionInfo* info = GetConnectionInfo(connection_id);
-  if (!info)
+  if (!info) {
     return;
+  }
 
   if (!info->is_websocket || info->is_websocket_pending) {
     LOG(ERROR) << "Invalid attempt to send WebSocket message for connection_id "
@@ -462,8 +485,9 @@ void CefServerImpl::OnHttpRequest(
 
   ConnectionInfo* info = GetConnectionInfo(connection_id);
   DCHECK(info);
-  if (!info)
+  if (!info) {
     return;
+  }
 
   DCHECK(!info->is_websocket);
 
@@ -478,8 +502,9 @@ void CefServerImpl::OnWebSocketRequest(
 
   ConnectionInfo* info = GetConnectionInfo(connection_id);
   DCHECK(info);
-  if (!info)
+  if (!info) {
     return;
+  }
 
   DCHECK(!info->is_websocket);
   info->is_websocket = true;
@@ -497,8 +522,9 @@ void CefServerImpl::OnWebSocketMessage(int connection_id, std::string data) {
   CEF_REQUIRE_HT();
 
   ConnectionInfo* info = GetConnectionInfo(connection_id);
-  if (!info)
+  if (!info) {
     return;
+  }
 
   DCHECK(info->is_websocket);
   DCHECK(!info->is_websocket_pending);
@@ -546,8 +572,9 @@ void CefServerImpl::StartOnHandlerThread(const std::string& address,
     server_.reset(new net::HttpServer(std::move(socket), this));
 
     net::IPEndPoint ip_address;
-    if (server_->GetLocalAddress(&ip_address) == net::OK)
+    if (server_->GetLocalAddress(&ip_address) == net::OK) {
       address_ = ip_address.ToString();
+    }
   }
 
   handler_->OnServerCreated(this);
@@ -650,8 +677,9 @@ CefServerImpl::ConnectionInfo* CefServerImpl::GetConnectionInfo(
   CEF_REQUIRE_HT();
   ConnectionInfoMap::const_iterator it =
       connection_info_map_.find(connection_id);
-  if (it != connection_info_map_.end())
+  if (it != connection_info_map_.end()) {
     return it->second.get();
+  }
 
   LOG(ERROR) << "Invalid connection_id " << connection_id;
   return nullptr;
@@ -661,8 +689,9 @@ void CefServerImpl::RemoveConnectionInfo(int connection_id) {
   CEF_REQUIRE_HT();
   ConnectionInfoMap::iterator it = connection_info_map_.find(connection_id);
   DCHECK(it != connection_info_map_.end());
-  if (it != connection_info_map_.end())
+  if (it != connection_info_map_.end()) {
     connection_info_map_.erase(it);
+  }
 }
 
 bool CefServerImpl::CurrentlyOnHandlerThread() const {
diff --git a/libcef/browser/simple_menu_model_impl.cc b/libcef/browser/simple_menu_model_impl.cc
index 75d15443b..917082add 100644
--- a/libcef/browser/simple_menu_model_impl.cc
+++ b/libcef/browser/simple_menu_model_impl.cc
@@ -70,43 +70,49 @@ void CefSimpleMenuModelImpl::Detach() {
     submenumap_.clear();
   }
 
-  if (is_owned_)
+  if (is_owned_) {
     delete model_;
+  }
   model_ = nullptr;
 }
 
 bool CefSimpleMenuModelImpl::IsSubMenu() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
   return is_submenu_;
 }
 
 bool CefSimpleMenuModelImpl::Clear() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   model_->Clear();
   return true;
 }
 
 size_t CefSimpleMenuModelImpl::GetCount() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return 0;
+  }
 
   return model_->GetItemCount();
 }
 
 bool CefSimpleMenuModelImpl::AddSeparator() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   model_->AddSeparator(ui::NORMAL_SEPARATOR);
   return true;
 }
 
 bool CefSimpleMenuModelImpl::AddItem(int command_id, const CefString& label) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   model_->AddItem(command_id, label);
   return true;
@@ -114,8 +120,9 @@ bool CefSimpleMenuModelImpl::AddItem(int command_id, const CefString& label) {
 
 bool CefSimpleMenuModelImpl::AddCheckItem(int command_id,
                                           const CefString& label) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   model_->AddCheckItem(command_id, label);
   return true;
@@ -124,8 +131,9 @@ bool CefSimpleMenuModelImpl::AddCheckItem(int command_id,
 bool CefSimpleMenuModelImpl::AddRadioItem(int command_id,
                                           const CefString& label,
                                           int group_id) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   model_->AddRadioItem(command_id, label, group_id);
   return true;
@@ -134,8 +142,9 @@ bool CefSimpleMenuModelImpl::AddRadioItem(int command_id,
 CefRefPtr<CefMenuModel> CefSimpleMenuModelImpl::AddSubMenu(
     int command_id,
     const CefString& label) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return nullptr;
+  }
 
   auto new_menu = CreateNewSubMenu(nullptr);
   model_->AddSubMenu(command_id, label, new_menu->model());
@@ -143,8 +152,9 @@ CefRefPtr<CefMenuModel> CefSimpleMenuModelImpl::AddSubMenu(
 }
 
 bool CefSimpleMenuModelImpl::InsertSeparatorAt(size_t index) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   model_->InsertSeparatorAt(index, ui::NORMAL_SEPARATOR);
   return true;
@@ -153,8 +163,9 @@ bool CefSimpleMenuModelImpl::InsertSeparatorAt(size_t index) {
 bool CefSimpleMenuModelImpl::InsertItemAt(size_t index,
                                           int command_id,
                                           const CefString& label) {
-  if (!VerifyContext() || !ValidIndex(index))
+  if (!VerifyContext() || !ValidIndex(index)) {
     return false;
+  }
 
   model_->InsertItemAt(index, command_id, label);
   return true;
@@ -163,8 +174,9 @@ bool CefSimpleMenuModelImpl::InsertItemAt(size_t index,
 bool CefSimpleMenuModelImpl::InsertCheckItemAt(size_t index,
                                                int command_id,
                                                const CefString& label) {
-  if (!VerifyContext() || !ValidIndex(index))
+  if (!VerifyContext() || !ValidIndex(index)) {
     return false;
+  }
 
   model_->InsertCheckItemAt(index, command_id, label);
   return true;
@@ -174,8 +186,9 @@ bool CefSimpleMenuModelImpl::InsertRadioItemAt(size_t index,
                                                int command_id,
                                                const CefString& label,
                                                int group_id) {
-  if (!VerifyContext() || !ValidIndex(index))
+  if (!VerifyContext() || !ValidIndex(index)) {
     return false;
+  }
 
   model_->InsertRadioItemAt(index, command_id, label, group_id);
   return true;
@@ -185,8 +198,9 @@ CefRefPtr<CefMenuModel> CefSimpleMenuModelImpl::InsertSubMenuAt(
     size_t index,
     int command_id,
     const CefString& label) {
-  if (!VerifyContext() || !ValidIndex(index))
+  if (!VerifyContext() || !ValidIndex(index)) {
     return nullptr;
+  }
 
   auto new_menu = CreateNewSubMenu(nullptr);
   model_->InsertSubMenuAt(index, command_id, label, new_menu->model());
@@ -198,8 +212,9 @@ bool CefSimpleMenuModelImpl::Remove(int command_id) {
 }
 
 bool CefSimpleMenuModelImpl::RemoveAt(size_t index) {
-  if (!VerifyContext() || !ValidIndex(index))
+  if (!VerifyContext() || !ValidIndex(index)) {
     return false;
+  }
 
   auto* sub_menu =
       static_cast<ui::SimpleMenuModel*>(model_->GetSubmenuModelAt(index));
@@ -216,18 +231,21 @@ bool CefSimpleMenuModelImpl::RemoveAt(size_t index) {
 }
 
 int CefSimpleMenuModelImpl::GetIndexOf(int command_id) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return kInvalidIndex;
+  }
 
   auto index = model_->GetIndexOfCommandId(command_id);
-  if (index.has_value())
+  if (index.has_value()) {
     return static_cast<int>(*index);
+  }
   return -1;
 }
 
 int CefSimpleMenuModelImpl::GetCommandIdAt(size_t index) {
-  if (!VerifyContext() || !ValidIndex(index))
+  if (!VerifyContext() || !ValidIndex(index)) {
     return kInvalidCommandId;
+  }
 
   return model_->GetCommandIdAt(index);
 }
@@ -242,8 +260,9 @@ CefString CefSimpleMenuModelImpl::GetLabel(int command_id) {
 }
 
 CefString CefSimpleMenuModelImpl::GetLabelAt(size_t index) {
-  if (!VerifyContext() || !ValidIndex(index))
+  if (!VerifyContext() || !ValidIndex(index)) {
     return CefString();
+  }
 
   return model_->GetLabelAt(index);
 }
@@ -253,8 +272,9 @@ bool CefSimpleMenuModelImpl::SetLabel(int command_id, const CefString& label) {
 }
 
 bool CefSimpleMenuModelImpl::SetLabelAt(size_t index, const CefString& label) {
-  if (!VerifyContext() || !ValidIndex(index))
+  if (!VerifyContext() || !ValidIndex(index)) {
     return false;
+  }
 
   model_->SetLabel(index, label);
   return true;
@@ -267,8 +287,9 @@ CefSimpleMenuModelImpl::MenuItemType CefSimpleMenuModelImpl::GetType(
 
 CefSimpleMenuModelImpl::MenuItemType CefSimpleMenuModelImpl::GetTypeAt(
     size_t index) {
-  if (!VerifyContext() || !ValidIndex(index))
+  if (!VerifyContext() || !ValidIndex(index)) {
     return MENUITEMTYPE_NONE;
+  }
 
   return GetCefItemType(model_->GetTypeAt(index));
 }
@@ -278,8 +299,9 @@ int CefSimpleMenuModelImpl::GetGroupId(int command_id) {
 }
 
 int CefSimpleMenuModelImpl::GetGroupIdAt(size_t index) {
-  if (!VerifyContext() || !ValidIndex(index))
+  if (!VerifyContext() || !ValidIndex(index)) {
     return kInvalidGroupId;
+  }
 
   return model_->GetGroupIdAt(index);
 }
@@ -298,14 +320,16 @@ CefRefPtr<CefMenuModel> CefSimpleMenuModelImpl::GetSubMenu(int command_id) {
 }
 
 CefRefPtr<CefMenuModel> CefSimpleMenuModelImpl::GetSubMenuAt(size_t index) {
-  if (!VerifyContext() || !ValidIndex(index))
+  if (!VerifyContext() || !ValidIndex(index)) {
     return nullptr;
+  }
 
   auto* sub_model =
       static_cast<ui::SimpleMenuModel*>(model_->GetSubmenuModelAt(index));
   auto it = submenumap_.find(sub_model);
-  if (it != submenumap_.end())
+  if (it != submenumap_.end()) {
     return it->second;
+  }
   return CreateNewSubMenu(sub_model);
 }
 
@@ -314,8 +338,9 @@ bool CefSimpleMenuModelImpl::IsVisible(int command_id) {
 }
 
 bool CefSimpleMenuModelImpl::IsVisibleAt(size_t index) {
-  if (!VerifyContext() || !ValidIndex(index))
+  if (!VerifyContext() || !ValidIndex(index)) {
     return false;
+  }
 
   return model_->IsVisibleAt(index);
 }
@@ -325,8 +350,9 @@ bool CefSimpleMenuModelImpl::SetVisible(int command_id, bool visible) {
 }
 
 bool CefSimpleMenuModelImpl::SetVisibleAt(size_t index, bool visible) {
-  if (!VerifyContext() || !ValidIndex(index))
+  if (!VerifyContext() || !ValidIndex(index)) {
     return false;
+  }
 
   model_->SetVisibleAt(index, visible);
   return true;
@@ -337,8 +363,9 @@ bool CefSimpleMenuModelImpl::IsEnabled(int command_id) {
 }
 
 bool CefSimpleMenuModelImpl::IsEnabledAt(size_t index) {
-  if (!VerifyContext() || !ValidIndex(index))
+  if (!VerifyContext() || !ValidIndex(index)) {
     return false;
+  }
 
   return model_->IsEnabledAt(index);
 }
@@ -348,8 +375,9 @@ bool CefSimpleMenuModelImpl::SetEnabled(int command_id, bool enabled) {
 }
 
 bool CefSimpleMenuModelImpl::SetEnabledAt(size_t index, bool enabled) {
-  if (!VerifyContext() || !ValidIndex(index))
+  if (!VerifyContext() || !ValidIndex(index)) {
     return false;
+  }
 
   model_->SetEnabledAt(index, enabled);
   return true;
@@ -360,15 +388,17 @@ bool CefSimpleMenuModelImpl::IsChecked(int command_id) {
 }
 
 bool CefSimpleMenuModelImpl::IsCheckedAt(size_t index) {
-  if (!VerifyContext() || !ValidIndex(index))
+  if (!VerifyContext() || !ValidIndex(index)) {
     return false;
+  }
 
   return model_->IsItemCheckedAt(index);
 }
 
 bool CefSimpleMenuModelImpl::SetChecked(int command_id, bool checked) {
-  if (!VerifyContext() || command_id == kInvalidIndex)
+  if (!VerifyContext() || command_id == kInvalidIndex) {
     return false;
+  }
 
   state_delegate_->SetChecked(command_id, checked);
   return true;
@@ -383,8 +413,9 @@ bool CefSimpleMenuModelImpl::HasAccelerator(int command_id) {
 }
 
 bool CefSimpleMenuModelImpl::HasAcceleratorAt(size_t index) {
-  if (!VerifyContext() || !ValidIndex(index))
+  if (!VerifyContext() || !ValidIndex(index)) {
     return false;
+  }
 
   ui::Accelerator accelerator;
   return model_->GetAcceleratorAt(index, &accelerator);
@@ -395,16 +426,20 @@ bool CefSimpleMenuModelImpl::SetAccelerator(int command_id,
                                             bool shift_pressed,
                                             bool ctrl_pressed,
                                             bool alt_pressed) {
-  if (!VerifyContext() || command_id == kInvalidIndex)
+  if (!VerifyContext() || command_id == kInvalidIndex) {
     return false;
+  }
 
   int modifiers = 0;
-  if (shift_pressed)
+  if (shift_pressed) {
     modifiers |= ui::EF_SHIFT_DOWN;
-  if (ctrl_pressed)
+  }
+  if (ctrl_pressed) {
     modifiers |= ui::EF_CONTROL_DOWN;
-  if (alt_pressed)
+  }
+  if (alt_pressed) {
     modifiers |= ui::EF_ALT_DOWN;
+  }
 
   state_delegate_->SetAccelerator(
       command_id,
@@ -422,8 +457,9 @@ bool CefSimpleMenuModelImpl::SetAcceleratorAt(size_t index,
 }
 
 bool CefSimpleMenuModelImpl::RemoveAccelerator(int command_id) {
-  if (!VerifyContext() || command_id == kInvalidIndex)
+  if (!VerifyContext() || command_id == kInvalidIndex) {
     return false;
+  }
   state_delegate_->SetAccelerator(command_id, absl::nullopt);
   return true;
 }
@@ -446,8 +482,9 @@ bool CefSimpleMenuModelImpl::GetAcceleratorAt(size_t index,
                                               bool& shift_pressed,
                                               bool& ctrl_pressed,
                                               bool& alt_pressed) {
-  if (!VerifyContext() || !ValidIndex(index))
+  if (!VerifyContext() || !ValidIndex(index)) {
     return false;
+  }
 
   ui::Accelerator accel;
   if (model_->GetAcceleratorAt(index, &accel)) {
@@ -507,8 +544,9 @@ bool CefSimpleMenuModelImpl::VerifyContext() {
     return false;
   }
 
-  if (!model_)
+  if (!model_) {
     return false;
+  }
 
   return true;
 }
diff --git a/libcef/browser/ssl_host_state_delegate.cc b/libcef/browser/ssl_host_state_delegate.cc
index ebc3f9b76..e97bc1ad3 100644
--- a/libcef/browser/ssl_host_state_delegate.cc
+++ b/libcef/browser/ssl_host_state_delegate.cc
@@ -88,8 +88,9 @@ void CefSSLHostStateDelegate::Clear(
        it != cert_policy_for_host_.end();) {
     auto next_it = std::next(it);
 
-    if (host_filter.Run(it->first))
+    if (host_filter.Run(it->first)) {
       cert_policy_for_host_.erase(it);
+    }
 
     it = next_it;
   }
diff --git a/libcef/browser/ssl_status_impl.cc b/libcef/browser/ssl_status_impl.cc
index 4330c70d4..f119bfaf9 100644
--- a/libcef/browser/ssl_status_impl.cc
+++ b/libcef/browser/ssl_status_impl.cc
@@ -33,7 +33,8 @@ cef_ssl_content_status_t CefSSLStatusImpl::GetContentStatus() {
 }
 
 CefRefPtr<CefX509Certificate> CefSSLStatusImpl::GetX509Certificate() {
-  if (certificate_ && !cef_certificate_)
+  if (certificate_ && !cef_certificate_) {
     cef_certificate_ = new CefX509CertificateImpl(certificate_);
+  }
   return cef_certificate_;
 }
diff --git a/libcef/browser/stream_impl.cc b/libcef/browser/stream_impl.cc
index 7e90c0697..1e4e40e69 100644
--- a/libcef/browser/stream_impl.cc
+++ b/libcef/browser/stream_impl.cc
@@ -19,8 +19,9 @@ CefRefPtr<CefStreamReader> CefStreamReader::CreateForFile(
 
   CefRefPtr<CefStreamReader> reader;
   FILE* file = base::OpenFile(base::FilePath(fileName), "rb");
-  if (file)
+  if (file) {
     reader = new CefFileReader(file, true);
+  }
   return reader;
 }
 
@@ -29,8 +30,9 @@ CefRefPtr<CefStreamReader> CefStreamReader::CreateForData(void* data,
   DCHECK(data != nullptr);
   DCHECK(size > 0);
   CefRefPtr<CefStreamReader> reader;
-  if (data && size > 0)
+  if (data && size > 0) {
     reader = new CefBytesReader(data, size, true);
+  }
   return reader;
 }
 
@@ -38,8 +40,9 @@ CefRefPtr<CefStreamReader> CefStreamReader::CreateForHandler(
     CefRefPtr<CefReadHandler> handler) {
   DCHECK(handler.get());
   CefRefPtr<CefStreamReader> reader;
-  if (handler.get())
+  if (handler.get()) {
     reader = new CefHandlerReader(handler);
+  }
   return reader;
 }
 
@@ -52,8 +55,9 @@ CefRefPtr<CefStreamWriter> CefStreamWriter::CreateForFile(
 
   CefRefPtr<CefStreamWriter> writer;
   FILE* file = base::OpenFile(base::FilePath(fileName), "wb");
-  if (file)
+  if (file) {
     writer = new CefFileWriter(file, true);
+  }
   return writer;
 }
 
@@ -61,8 +65,9 @@ CefRefPtr<CefStreamWriter> CefStreamWriter::CreateForHandler(
     CefRefPtr<CefWriteHandler> handler) {
   DCHECK(handler.get());
   CefRefPtr<CefStreamWriter> writer;
-  if (handler.get())
+  if (handler.get()) {
     writer = new CefHandlerWriter(handler);
+  }
   return writer;
 }
 
@@ -73,8 +78,9 @@ CefFileReader::CefFileReader(FILE* file, bool close)
 
 CefFileReader::~CefFileReader() {
   base::AutoLock lock_scope(lock_);
-  if (close_)
+  if (close_) {
     base::CloseFile(file_);
+  }
 }
 
 size_t CefFileReader::Read(void* ptr, size_t size, size_t n) {
@@ -112,8 +118,9 @@ CefFileWriter::CefFileWriter(FILE* file, bool close)
 
 CefFileWriter::~CefFileWriter() {
   base::AutoLock lock_scope(lock_);
-  if (close_)
+  if (close_) {
     base::CloseFile(file_);
+  }
 }
 
 size_t CefFileWriter::Write(const void* ptr, size_t size, size_t n) {
@@ -161,22 +168,25 @@ int CefBytesReader::Seek(int64 offset, int whence) {
   base::AutoLock lock_scope(lock_);
   switch (whence) {
     case SEEK_CUR:
-      if (offset_ + offset > datasize_ || offset_ + offset < 0)
+      if (offset_ + offset > datasize_ || offset_ + offset < 0) {
         break;
+      }
       offset_ += offset;
       rv = 0;
       break;
     case SEEK_END: {
       int64 offset_abs = std::abs(offset);
-      if (offset_abs > datasize_)
+      if (offset_abs > datasize_) {
         break;
+      }
       offset_ = datasize_ - offset_abs;
       rv = 0;
       break;
     }
     case SEEK_SET:
-      if (offset > datasize_ || offset < 0)
+      if (offset > datasize_ || offset < 0) {
         break;
+      }
       offset_ = offset;
       rv = 0;
       break;
@@ -197,8 +207,9 @@ int CefBytesReader::Eof() {
 
 void CefBytesReader::SetData(void* data, int64 datasize, bool copy) {
   base::AutoLock lock_scope(lock_);
-  if (copy_)
+  if (copy_) {
     free(data_);
+  }
 
   copy_ = copy;
   offset_ = 0;
@@ -207,8 +218,9 @@ void CefBytesReader::SetData(void* data, int64 datasize, bool copy) {
   if (copy) {
     data_ = malloc(datasize);
     DCHECK(data_ != nullptr);
-    if (data_)
+    if (data_) {
       memcpy(data_, data, datasize);
+    }
   } else {
     data_ = data;
   }
@@ -225,8 +237,9 @@ CefBytesWriter::CefBytesWriter(size_t grow)
 
 CefBytesWriter::~CefBytesWriter() {
   base::AutoLock lock_scope(lock_);
-  if (data_)
+  if (data_) {
     free(data_);
+  }
 }
 
 size_t CefBytesWriter::Write(const void* ptr, size_t size, size_t n) {
@@ -249,22 +262,25 @@ int CefBytesWriter::Seek(int64 offset, int whence) {
   base::AutoLock lock_scope(lock_);
   switch (whence) {
     case SEEK_CUR:
-      if (offset_ + offset > datasize_ || offset_ + offset < 0)
+      if (offset_ + offset > datasize_ || offset_ + offset < 0) {
         break;
+      }
       offset_ += offset;
       rv = 0;
       break;
     case SEEK_END: {
       int64 offset_abs = std::abs(offset);
-      if (offset_abs > datasize_)
+      if (offset_abs > datasize_) {
         break;
+      }
       offset_ = datasize_ - offset_abs;
       rv = 0;
       break;
     }
     case SEEK_SET:
-      if (offset > datasize_ || offset < 0)
+      if (offset > datasize_ || offset < 0) {
         break;
+      }
       offset_ = offset;
       rv = 0;
       break;
diff --git a/libcef/browser/test/test_server_impl.cc b/libcef/browser/test/test_server_impl.cc
index 033a19c91..b02d605bd 100644
--- a/libcef/browser/test/test_server_impl.cc
+++ b/libcef/browser/test/test_server_impl.cc
@@ -108,8 +108,9 @@ class CefHttpResponse : public HttpResponse {
         new CefTestServerConnectionImpl(delegate));
     const bool handled =
         handler_->OnTestServerRequest(server_, request_, connection.get());
-    if (handled)
+    if (handled) {
       return;
+    }
 
     LOG(WARNING) << "Request not handled. Returning 404: "
                  << request_->GetURL().ToString();
@@ -148,8 +149,9 @@ CefRefPtr<CefRequest> CreateCefRequest(const HttpRequest& request) {
   auto cef_request = CefRequest::Create();
   cef_request->Set(request.GetURL().spec(), request.method_string, post_data,
                    header_map);
-  if (!referer.empty())
+  if (!referer.empty()) {
     cef_request->SetReferrer(referer, REFERRER_POLICY_DEFAULT);
+  }
   return cef_request;
 }
 
diff --git a/libcef/browser/thread_util.h b/libcef/browser/thread_util.h
index 205578576..f6651b784 100644
--- a/libcef/browser/thread_util.h
+++ b/libcef/browser/thread_util.h
@@ -88,22 +88,26 @@ auto CEF_TASK_RUNNER() {
       FROM_HERE, base::BlockingType::WILL_BLOCK)
 
 // Same as IMPLEMENT_REFCOUNTING() but using the specified Destructor.
-#define IMPLEMENT_REFCOUNTING_EX(ClassName, Destructor)              \
- public:                                                             \
-  void AddRef() const override { ref_count_.AddRef(); }              \
-  bool Release() const override {                                    \
-    if (ref_count_.Release()) {                                      \
-      Destructor::Destruct(this);                                    \
-      return true;                                                   \
-    }                                                                \
-    return false;                                                    \
-  }                                                                  \
-  bool HasOneRef() const override { return ref_count_.HasOneRef(); } \
-  bool HasAtLeastOneRef() const override {                           \
-    return ref_count_.HasAtLeastOneRef();                            \
-  }                                                                  \
-                                                                     \
- private:                                                            \
+#define IMPLEMENT_REFCOUNTING_EX(ClassName, Destructor) \
+ public:                                                \
+  void AddRef() const override {                        \
+    ref_count_.AddRef();                                \
+  }                                                     \
+  bool Release() const override {                       \
+    if (ref_count_.Release()) {                         \
+      Destructor::Destruct(this);                       \
+      return true;                                      \
+    }                                                   \
+    return false;                                       \
+  }                                                     \
+  bool HasOneRef() const override {                     \
+    return ref_count_.HasOneRef();                      \
+  }                                                     \
+  bool HasAtLeastOneRef() const override {              \
+    return ref_count_.HasAtLeastOneRef();               \
+  }                                                     \
+                                                        \
+ private:                                               \
   CefRefCount ref_count_
 
 #define IMPLEMENT_REFCOUNTING_DELETE_ON_UIT(ClassName) \
diff --git a/libcef/browser/trace_impl.cc b/libcef/browser/trace_impl.cc
index 6fdab14d6..8e7dc3728 100644
--- a/libcef/browser/trace_impl.cc
+++ b/libcef/browser/trace_impl.cc
@@ -22,8 +22,9 @@ bool CefBeginTracing(const CefString& categories,
   }
 
   CefTraceSubscriber* subscriber = CefContext::Get()->GetTraceSubscriber();
-  if (!subscriber)
+  if (!subscriber) {
     return false;
+  }
 
   return subscriber->BeginTracing(categories, callback);
 }
@@ -41,8 +42,9 @@ bool CefEndTracing(const CefString& tracing_file,
   }
 
   CefTraceSubscriber* subscriber = CefContext::Get()->GetTraceSubscriber();
-  if (!subscriber)
+  if (!subscriber) {
     return false;
+  }
 
   return subscriber->EndTracing(base::FilePath(tracing_file), callback);
 }
diff --git a/libcef/browser/trace_subscriber.cc b/libcef/browser/trace_subscriber.cc
index e4025b60a..2ed760269 100644
--- a/libcef/browser/trace_subscriber.cc
+++ b/libcef/browser/trace_subscriber.cc
@@ -20,8 +20,9 @@ void CreateTemporaryFileOnBackgroundThread(
     base::OnceCallback<void(const base::FilePath&)> callback) {
   CEF_REQUIRE_BLOCKING();
   base::FilePath file_path;
-  if (!base::CreateTemporaryFile(&file_path))
+  if (!base::CreateTemporaryFile(&file_path)) {
     LOG(ERROR) << "Failed to create temporary file.";
+  }
   message_loop_proxy->PostTask(FROM_HERE,
                                base::BindOnce(std::move(callback), file_path));
 }
@@ -61,8 +62,9 @@ CefTraceSubscriber::CefTraceSubscriber()
 
 CefTraceSubscriber::~CefTraceSubscriber() {
   CEF_REQUIRE_UIT();
-  if (collecting_trace_data_)
+  if (collecting_trace_data_) {
     TracingController::GetInstance()->StopTracing(nullptr);
+  }
 }
 
 bool CefTraceSubscriber::BeginTracing(
@@ -70,8 +72,9 @@ bool CefTraceSubscriber::BeginTracing(
     CefRefPtr<CefCompletionCallback> callback) {
   CEF_REQUIRE_UIT();
 
-  if (collecting_trace_data_)
+  if (collecting_trace_data_) {
     return false;
+  }
 
   collecting_trace_data_ = true;
 
@@ -93,8 +96,9 @@ bool CefTraceSubscriber::EndTracing(const base::FilePath& tracing_file,
                                     CefRefPtr<CefEndTracingCallback> callback) {
   CEF_REQUIRE_UIT();
 
-  if (!collecting_trace_data_)
+  if (!collecting_trace_data_) {
     return false;
+  }
 
   if (!callback.get()) {
     // Discard the trace data.
@@ -128,8 +132,9 @@ void CefTraceSubscriber::ContinueEndTracing(
     CefRefPtr<CefEndTracingCallback> callback,
     const base::FilePath& tracing_file) {
   CEF_REQUIRE_UIT();
-  if (!tracing_file.empty())
+  if (!tracing_file.empty()) {
     EndTracing(tracing_file, callback);
+  }
 }
 
 void CefTraceSubscriber::OnTracingFileResult(
diff --git a/libcef/browser/views/basic_label_button_impl.cc b/libcef/browser/views/basic_label_button_impl.cc
index 19f3de108..41ae1fe3b 100644
--- a/libcef/browser/views/basic_label_button_impl.cc
+++ b/libcef/browser/views/basic_label_button_impl.cc
@@ -21,8 +21,9 @@ CefRefPtr<CefBasicLabelButtonImpl> CefBasicLabelButtonImpl::Create(
   CefRefPtr<CefBasicLabelButtonImpl> label_button =
       new CefBasicLabelButtonImpl(delegate);
   label_button->Initialize();
-  if (!text.empty())
+  if (!text.empty()) {
     label_button->SetText(text);
+  }
   return label_button;
 }
 
diff --git a/libcef/browser/views/box_layout_impl.cc b/libcef/browser/views/box_layout_impl.cc
index d388eaeca..0305ef826 100644
--- a/libcef/browser/views/box_layout_impl.cc
+++ b/libcef/browser/views/box_layout_impl.cc
@@ -20,17 +20,20 @@ CefRefPtr<CefBoxLayoutImpl> CefBoxLayoutImpl::Create(
 void CefBoxLayoutImpl::SetFlexForView(CefRefPtr<CefView> view, int flex) {
   CEF_REQUIRE_VALID_RETURN_VOID();
   DCHECK_GE(flex, 0);
-  if (flex < 0)
+  if (flex < 0) {
     return;
+  }
 
   DCHECK(view && view->IsValid() && view->IsAttached());
-  if (!view || !view->IsValid() || !view->IsAttached())
+  if (!view || !view->IsValid() || !view->IsAttached()) {
     return;
+  }
 
   views::View* view_ptr = view_util::GetFor(view);
   DCHECK_EQ(view_ptr->parent(), owner_view());
-  if (view_ptr->parent() != owner_view())
+  if (view_ptr->parent() != owner_view()) {
     return;
+  }
 
   layout()->SetFlexForView(view_ptr, flex);
 }
@@ -38,13 +41,15 @@ void CefBoxLayoutImpl::SetFlexForView(CefRefPtr<CefView> view, int flex) {
 void CefBoxLayoutImpl::ClearFlexForView(CefRefPtr<CefView> view) {
   CEF_REQUIRE_VALID_RETURN_VOID();
   DCHECK(view && view->IsValid() && view->IsAttached());
-  if (!view || !view->IsValid() || !view->IsAttached())
+  if (!view || !view->IsValid() || !view->IsAttached()) {
     return;
+  }
 
   views::View* view_ptr = view_util::GetFor(view);
   DCHECK_EQ(view_ptr->parent(), owner_view());
-  if (view_ptr->parent() != owner_view())
+  if (view_ptr->parent() != owner_view()) {
     return;
+  }
 
   layout()->ClearFlexForView(view_ptr);
 }
@@ -70,7 +75,8 @@ views::BoxLayout* CefBoxLayoutImpl::CreateLayout() {
       settings_.inside_border_insets.bottom,
       settings_.inside_border_insets.right));
   layout->set_minimum_cross_axis_size(settings_.minimum_cross_axis_size);
-  if (settings_.default_flex > 0)
+  if (settings_.default_flex > 0) {
     layout->SetDefaultFlex(settings_.default_flex);
+  }
   return layout;
 }
diff --git a/libcef/browser/views/browser_platform_delegate_views.cc b/libcef/browser/views/browser_platform_delegate_views.cc
index ffaef8818..fc5af6b82 100644
--- a/libcef/browser/views/browser_platform_delegate_views.cc
+++ b/libcef/browser/views/browser_platform_delegate_views.cc
@@ -38,8 +38,9 @@ class PopupWindowDelegate : public CefWindowDelegate {
 
   bool CanClose(CefRefPtr<CefWindow> window) override {
     CefRefPtr<CefBrowser> browser = browser_view_->GetBrowser();
-    if (browser)
+    if (browser) {
       return browser->GetHost()->TryCloseBrowser();
+    }
     return true;
   }
 
@@ -55,8 +56,9 @@ CefBrowserPlatformDelegateViews::CefBrowserPlatformDelegateViews(
     std::unique_ptr<CefBrowserPlatformDelegateNative> native_delegate,
     CefRefPtr<CefBrowserViewImpl> browser_view)
     : native_delegate_(std::move(native_delegate)) {
-  if (browser_view)
+  if (browser_view) {
     SetBrowserView(browser_view);
+  }
   native_delegate_->set_windowless_handler(this);
 }
 
@@ -92,15 +94,17 @@ void CefBrowserPlatformDelegateViews::BrowserCreated(
 void CefBrowserPlatformDelegateViews::NotifyBrowserCreated() {
   DCHECK(browser_view_);
   DCHECK(browser_);
-  if (browser_view_->delegate())
+  if (browser_view_->delegate()) {
     browser_view_->delegate()->OnBrowserCreated(browser_view_, browser_);
+  }
 }
 
 void CefBrowserPlatformDelegateViews::NotifyBrowserDestroyed() {
   DCHECK(browser_view_);
   DCHECK(browser_);
-  if (browser_view_->delegate())
+  if (browser_view_->delegate()) {
     browser_view_->delegate()->OnBrowserDestroyed(browser_view_, browser_);
+  }
 }
 
 void CefBrowserPlatformDelegateViews::BrowserDestroyed(
@@ -119,8 +123,9 @@ bool CefBrowserPlatformDelegateViews::CreateHostWindow() {
 
 void CefBrowserPlatformDelegateViews::CloseHostWindow() {
   views::Widget* widget = GetWindowWidget();
-  if (widget && !widget->IsClosed())
+  if (widget && !widget->IsClosed()) {
     widget->Close();
+  }
 }
 
 CefWindowHandle CefBrowserPlatformDelegateViews::GetHostWindowHandle() const {
@@ -128,8 +133,9 @@ CefWindowHandle CefBrowserPlatformDelegateViews::GetHostWindowHandle() const {
 }
 
 views::Widget* CefBrowserPlatformDelegateViews::GetWindowWidget() const {
-  if (browser_view_->root_view())
+  if (browser_view_->root_view()) {
     return browser_view_->root_view()->GetWidget();
+  }
   return nullptr;
 }
 
@@ -224,8 +230,9 @@ void CefBrowserPlatformDelegateViews::SetFocus(bool setFocus) {
   if (setFocus && browser_view_->root_view()) {
     if (auto widget = GetWindowWidget()) {
       // Don't activate a minimized Widget, or it will be shown.
-      if (widget->IsMinimized())
+      if (widget->IsMinimized()) {
         return;
+      }
     }
     browser_view_->root_view()->RequestFocus();
   }
@@ -234,8 +241,9 @@ void CefBrowserPlatformDelegateViews::SetFocus(bool setFocus) {
 gfx::Point CefBrowserPlatformDelegateViews::GetScreenPoint(
     const gfx::Point& view_pt,
     bool want_dip_coords) const {
-  if (!browser_view_->root_view())
+  if (!browser_view_->root_view()) {
     return view_pt;
+  }
 
   gfx::Point screen_point = view_pt;
   view_util::ConvertPointToScreen(browser_view_->root_view(), &screen_point,
diff --git a/libcef/browser/views/browser_view_impl.cc b/libcef/browser/views/browser_view_impl.cc
index 57e53450b..a0cd075ff 100644
--- a/libcef/browser/views/browser_view_impl.cc
+++ b/libcef/browser/views/browser_view_impl.cc
@@ -34,8 +34,9 @@ CefRefPtr<CefBrowserView> CefBrowserView::GetForBrowser(
 
   CefBrowserHostBase* browser_impl =
       static_cast<CefBrowserHostBase*>(browser.get());
-  if (browser_impl && browser_impl->is_views_hosted())
+  if (browser_impl && browser_impl->is_views_hosted()) {
     return browser_impl->GetBrowserView();
+  }
   return nullptr;
 }
 
@@ -84,8 +85,9 @@ CefRefPtr<CefBrowserViewImpl> CefBrowserViewImpl::CreateForPopup(
 
 void CefBrowserViewImpl::WebContentsCreated(
     content::WebContents* web_contents) {
-  if (web_view())
+  if (web_view()) {
     web_view()->SetWebContents(web_contents);
+  }
 }
 
 void CefBrowserViewImpl::BrowserCreated(
@@ -99,21 +101,25 @@ void CefBrowserViewImpl::BrowserDestroyed(CefBrowserHostBase* browser) {
   DCHECK_EQ(browser, browser_);
   browser_ = nullptr;
 
-  if (web_view())
+  if (web_view()) {
     web_view()->SetWebContents(nullptr);
+  }
 }
 
 bool CefBrowserViewImpl::HandleKeyboardEvent(
     const content::NativeWebKeyboardEvent& event) {
-  if (!root_view())
+  if (!root_view()) {
     return false;
+  }
 
   views::FocusManager* focus_manager = root_view()->GetFocusManager();
-  if (!focus_manager)
+  if (!focus_manager) {
     return false;
+  }
 
-  if (HandleAccelerator(event, focus_manager))
+  if (HandleAccelerator(event, focus_manager)) {
     return true;
+  }
 
   // Give the CefWindowDelegate a chance to handle the event.
   CefRefPtr<CefWindow> window =
@@ -148,8 +154,9 @@ CefRefPtr<CefView> CefBrowserViewImpl::GetChromeToolbar() {
 
 void CefBrowserViewImpl::SetPreferAccelerators(bool prefer_accelerators) {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (web_view())
+  if (web_view()) {
     web_view()->set_allow_accelerators(prefer_accelerators);
+  }
 }
 
 void CefBrowserViewImpl::RequestFocus() {
@@ -163,8 +170,9 @@ void CefBrowserViewImpl::RequestFocus() {
 void CefBrowserViewImpl::SetBackgroundColor(cef_color_t color) {
   CEF_REQUIRE_VALID_RETURN_VOID();
   ParentClass::SetBackgroundColor(color);
-  if (web_view())
+  if (web_view()) {
     web_view()->SetResizeBackgroundColor(color);
+  }
 }
 
 void CefBrowserViewImpl::Detach() {
@@ -186,8 +194,9 @@ void CefBrowserViewImpl::Detach() {
 void CefBrowserViewImpl::GetDebugInfo(base::DictionaryValue* info,
                                       bool include_children) {
   ParentClass::GetDebugInfo(info, include_children);
-  if (browser_)
+  if (browser_) {
     info->SetString("url", browser_->GetMainFrame()->GetURL().ToString());
+  }
 }
 
 void CefBrowserViewImpl::OnBrowserViewAdded() {
@@ -204,8 +213,9 @@ void CefBrowserViewImpl::OnBrowserViewAdded() {
 }
 
 void CefBrowserViewImpl::OnBoundsChanged() {
-  if (!on_bounds_changed_.is_null())
+  if (!on_bounds_changed_.is_null()) {
     on_bounds_changed_.Run();
+  }
 }
 
 CefBrowserViewImpl::CefBrowserViewImpl(
@@ -251,8 +261,9 @@ void CefBrowserViewImpl::InitializeRootView() {
 }
 
 views::WebView* CefBrowserViewImpl::web_view() const {
-  if (!root_view())
+  if (!root_view()) {
     return nullptr;
+  }
 
   if (cef::IsChromeRuntimeEnabled()) {
     return static_cast<ChromeBrowserView*>(root_view())->contents_web_view();
@@ -287,8 +298,9 @@ bool CefBrowserViewImpl::HandleAccelerator(
     // set the flag and fix it if no event was handled.
     ignore_next_char_event_ = true;
 
-    if (focus_manager->ProcessAccelerator(accelerator))
+    if (focus_manager->ProcessAccelerator(accelerator)) {
       return true;
+    }
 
     // ProcessAccelerator didn't handle the accelerator, so we know both
     // that |this| is still valid, and that we didn't want to set the flag.
diff --git a/libcef/browser/views/browser_view_view.cc b/libcef/browser/views/browser_view_view.cc
index 35bbf94aa..70ee77201 100644
--- a/libcef/browser/views/browser_view_view.cc
+++ b/libcef/browser/views/browser_view_view.cc
@@ -25,8 +25,9 @@ void CefBrowserViewView::ViewHierarchyChanged(
       // this View to a CefWindow with FillLayout and then calling
       // CefWindow::Show() without first resizing the CefWindow.
       size = details.parent->GetPreferredSize();
-      if (!size.IsEmpty())
+      if (!size.IsEmpty()) {
         SetSize(size);
+      }
     }
 
     browser_view_delegate_->OnBrowserViewAdded();
diff --git a/libcef/browser/views/button_view.h b/libcef/browser/views/button_view.h
index eecaf53e4..04441ccb6 100644
--- a/libcef/browser/views/button_view.h
+++ b/libcef/browser/views/button_view.h
@@ -51,15 +51,17 @@ CEF_BUTTON_VIEW_T class CefButtonView : public CEF_VIEW_VIEW_D {
 CEF_BUTTON_VIEW_T void CEF_BUTTON_VIEW_D::StateChanged(
     views::Button::ButtonState old_state) {
   ParentClass::StateChanged(old_state);
-  if (ParentClass::cef_delegate())
+  if (ParentClass::cef_delegate()) {
     ParentClass::cef_delegate()->OnButtonStateChanged(GetCefButton());
+  }
 }
 
 CEF_BUTTON_VIEW_T void CEF_BUTTON_VIEW_D::ButtonPressed(
     const ui::Event& event) {
   // Callback may trigger new animation state.
-  if (ParentClass::cef_delegate())
+  if (ParentClass::cef_delegate()) {
     ParentClass::cef_delegate()->OnButtonPressed(GetCefButton());
+  }
   if (views::InkDrop::Get(this)->ink_drop_mode() !=
           views::InkDropHost::InkDropMode::OFF &&
       !ParentClass::IsFocusable() &&
diff --git a/libcef/browser/views/display_impl.cc b/libcef/browser/views/display_impl.cc
index 57aa20dff..6c95c786b 100644
--- a/libcef/browser/views/display_impl.cc
+++ b/libcef/browser/views/display_impl.cc
@@ -47,8 +47,9 @@ void CefDisplay::GetAllDisplays(std::vector<CefRefPtr<CefDisplay>>& displays) {
 
   using DisplayVector = std::vector<display::Display>;
   DisplayVector vec = display::Screen::GetScreen()->GetAllDisplays();
-  for (size_t i = 0; i < vec.size(); ++i)
+  for (size_t i = 0; i < vec.size(); ++i) {
     displays.push_back(new CefDisplayImpl(vec[i]));
+  }
 }
 
 // static
diff --git a/libcef/browser/views/label_button_impl.h b/libcef/browser/views/label_button_impl.h
index a0b3197ff..f1513a851 100644
--- a/libcef/browser/views/label_button_impl.h
+++ b/libcef/browser/views/label_button_impl.h
@@ -78,8 +78,9 @@ CEF_LABEL_BUTTON_IMPL_T void CEF_LABEL_BUTTON_IMPL_D::SetImage(
     CefRefPtr<CefImage> image) {
   CEF_REQUIRE_VALID_RETURN_VOID();
   gfx::ImageSkia image_skia;
-  if (image)
+  if (image) {
     image_skia = static_cast<CefImageImpl*>(image.get())->AsImageSkia();
+  }
   ParentClass::root_view()->SetImage(
       static_cast<views::Button::ButtonState>(button_state), image_skia);
 }
@@ -89,8 +90,9 @@ CEF_LABEL_BUTTON_IMPL_T CefRefPtr<CefImage> CEF_LABEL_BUTTON_IMPL_D::GetImage(
   CEF_REQUIRE_VALID_RETURN(nullptr);
   const gfx::ImageSkia& image_skia = ParentClass::root_view()->GetImage(
       static_cast<views::Button::ButtonState>(button_state));
-  if (image_skia.isNull())
+  if (image_skia.isNull()) {
     return nullptr;
+  }
   return new CefImageImpl(image_skia);
 }
 
diff --git a/libcef/browser/views/layout_util.cc b/libcef/browser/views/layout_util.cc
index 305438d5e..1d5602edb 100644
--- a/libcef/browser/views/layout_util.cc
+++ b/libcef/browser/views/layout_util.cc
@@ -19,8 +19,9 @@ class UserData : public base::SupportsUserData::Data {
  public:
   static CefRefPtr<CefLayout> GetFor(const views::View* view) {
     UserData* data = static_cast<UserData*>(view->GetUserData(UserDataKey()));
-    if (data)
+    if (data) {
       return data->layout_;
+    }
     return nullptr;
   }
 
diff --git a/libcef/browser/views/menu_button_impl.cc b/libcef/browser/views/menu_button_impl.cc
index 6547277b0..d74d2cf68 100644
--- a/libcef/browser/views/menu_button_impl.cc
+++ b/libcef/browser/views/menu_button_impl.cc
@@ -22,12 +22,14 @@ CefRefPtr<CefMenuButtonImpl> CefMenuButtonImpl::Create(
     const CefString& text) {
   CEF_REQUIRE_UIT_RETURN(nullptr);
   DCHECK(delegate);
-  if (!delegate)
+  if (!delegate) {
     return nullptr;
+  }
   CefRefPtr<CefMenuButtonImpl> menu_button = new CefMenuButtonImpl(delegate);
   menu_button->Initialize();
-  if (!text.empty())
+  if (!text.empty()) {
     menu_button->SetText(text);
+  }
   return menu_button;
 }
 
diff --git a/libcef/browser/views/menu_runner_views.cc b/libcef/browser/views/menu_runner_views.cc
index 630dabe75..14b3b55d5 100644
--- a/libcef/browser/views/menu_runner_views.cc
+++ b/libcef/browser/views/menu_runner_views.cc
@@ -15,8 +15,9 @@ bool CefMenuRunnerViews::RunContextMenu(
     CefMenuModelImpl* model,
     const content::ContextMenuParams& params) {
   CefRefPtr<CefWindow> window = browser_view_->GetWindow();
-  if (!window)
+  if (!window) {
     return false;
+  }
 
   CefPoint screen_point(params.x, params.y);
   browser_view_->ConvertPointToScreen(screen_point);
@@ -27,8 +28,9 @@ bool CefMenuRunnerViews::RunContextMenu(
 
 void CefMenuRunnerViews::CancelContextMenu() {
   CefRefPtr<CefWindow> window = browser_view_->GetWindow();
-  if (window)
+  if (window) {
     window->CancelMenu();
+  }
 }
 
 bool CefMenuRunnerViews::FormatLabel(std::u16string& label) {
diff --git a/libcef/browser/views/overlay_view_host.cc b/libcef/browser/views/overlay_view_host.cc
index 000e21b8e..ec61fd656 100644
--- a/libcef/browser/views/overlay_view_host.cc
+++ b/libcef/browser/views/overlay_view_host.cc
@@ -263,16 +263,18 @@ void CefOverlayViewHost::MoveIfNecessary() {
 
 void CefOverlayViewHost::SetOverlayBounds(const gfx::Rect& bounds) {
   // Avoid re-entrancy of this method.
-  if (bounds_changing_)
+  if (bounds_changing_) {
     return;
+  }
 
   gfx::Rect new_bounds = bounds;
 
   // Keep the result inside the widget.
   new_bounds.Intersect(window_view_->bounds());
 
-  if (new_bounds == bounds_)
+  if (new_bounds == bounds_) {
     return;
+  }
 
   bounds_changing_ = true;
 
@@ -286,8 +288,9 @@ void CefOverlayViewHost::SetOverlayBounds(const gfx::Rect& bounds) {
 }
 
 void CefOverlayViewHost::SetOverlayInsets(const CefInsets& insets) {
-  if (insets == insets_)
+  if (insets == insets_) {
     return;
+  }
   insets_ = insets;
   MoveIfNecessary();
 }
diff --git a/libcef/browser/views/panel_impl.h b/libcef/browser/views/panel_impl.h
index 9695a7b1c..6b47ada88 100644
--- a/libcef/browser/views/panel_impl.h
+++ b/libcef/browser/views/panel_impl.h
@@ -112,8 +112,9 @@ CEF_PANEL_IMPL_T void CEF_PANEL_IMPL_D::AddChildView(CefRefPtr<CefView> view) {
   CEF_REQUIRE_VALID_RETURN_VOID();
   DCHECK(view.get());
   DCHECK(view->IsValid());
-  if (!view.get() || !view->IsValid())
+  if (!view.get() || !view->IsValid()) {
     return;
+  }
 
   auto* view_ptr = view->IsAttached()
                        ? view_util::GetFor(view)
@@ -150,14 +151,16 @@ CEF_PANEL_IMPL_T void CEF_PANEL_IMPL_D::ReorderChildView(
   DCHECK(view.get());
   DCHECK(view->IsValid());
   DCHECK(view->IsAttached());
-  if (!view.get() || !view->IsValid() || !view->IsAttached())
+  if (!view.get() || !view->IsValid() || !view->IsAttached()) {
     return;
+  }
 
   views::View* view_ptr = view_util::GetFor(view);
   DCHECK(view_ptr);
   DCHECK_EQ(view_ptr->parent(), ParentClass::content_view());
-  if (!view_ptr || view_ptr->parent() != ParentClass::content_view())
+  if (!view_ptr || view_ptr->parent() != ParentClass::content_view()) {
     return;
+  }
 
   ParentClass::content_view()->ReorderChildView(view_ptr, index);
 }
@@ -168,14 +171,16 @@ CEF_PANEL_IMPL_T void CEF_PANEL_IMPL_D::RemoveChildView(
   DCHECK(view.get());
   DCHECK(view->IsValid());
   DCHECK(view->IsAttached());
-  if (!view.get() || !view->IsValid() || !view->IsAttached())
+  if (!view.get() || !view->IsValid() || !view->IsAttached()) {
     return;
+  }
 
   views::View* view_ptr = view_util::GetFor(view);
   DCHECK(view_ptr);
   DCHECK_EQ(view_ptr->parent(), ParentClass::content_view());
-  if (!view_ptr || view_ptr->parent() != ParentClass::content_view())
+  if (!view_ptr || view_ptr->parent() != ParentClass::content_view()) {
     return;
+  }
 
   ParentClass::content_view()->RemoveChildView(view_ptr);
   view_util::ResumeOwnership(view);
@@ -202,8 +207,9 @@ CEF_PANEL_IMPL_T CefRefPtr<CefView> CEF_PANEL_IMPL_D::GetChildViewAt(
   DCHECK_LT(static_cast<unsigned int>(index),
             ParentClass::content_view()->children().size());
   if (index < 0 || (static_cast<unsigned int>(index) >=
-                    ParentClass::content_view()->children().size()))
+                    ParentClass::content_view()->children().size())) {
     return nullptr;
+  }
 
   CefRefPtr<CefView> view =
       view_util::GetFor(ParentClass::content_view()->children()[index], false);
diff --git a/libcef/browser/views/scroll_view_impl.cc b/libcef/browser/views/scroll_view_impl.cc
index 61d3fd01c..fb9a97187 100644
--- a/libcef/browser/views/scroll_view_impl.cc
+++ b/libcef/browser/views/scroll_view_impl.cc
@@ -24,8 +24,9 @@ void CefScrollViewImpl::SetContentView(CefRefPtr<CefView> view) {
   DCHECK(view.get());
   DCHECK(view->IsValid());
   DCHECK(!view->IsAttached());
-  if (!view.get() || !view->IsValid() || view->IsAttached())
+  if (!view.get() || !view->IsValid() || view->IsAttached()) {
     return;
+  }
 
   root_view()->SetContents(view_util::PassOwnership(view));
 }
diff --git a/libcef/browser/views/textfield_impl.cc b/libcef/browser/views/textfield_impl.cc
index 5b4e7e4ee..f1afd97df 100644
--- a/libcef/browser/views/textfield_impl.cc
+++ b/libcef/browser/views/textfield_impl.cc
@@ -155,10 +155,11 @@ void CefTextfieldImpl::SetFontList(const CefString& font_list) {
 void CefTextfieldImpl::ApplyTextColor(cef_color_t color,
                                       const CefRange& range) {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (range.from == range.to)
+  if (range.from == range.to) {
     root_view()->SetColor(color);
-  else
+  } else {
     root_view()->ApplyColor(color, gfx::Range(range.from, range.to));
+  }
 }
 
 void CefTextfieldImpl::ApplyTextStyle(cef_text_style_t style,
@@ -180,9 +181,10 @@ bool CefTextfieldImpl::IsCommandEnabled(cef_text_field_commands_t command_id) {
 
 void CefTextfieldImpl::ExecuteCommand(cef_text_field_commands_t command_id) {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (root_view()->IsCommandIdEnabled(CefCommandIdToChromeId(command_id)))
+  if (root_view()->IsCommandIdEnabled(CefCommandIdToChromeId(command_id))) {
     root_view()->ExecuteCommand(CefCommandIdToChromeId(command_id),
                                 ui::EF_NONE);
+  }
 }
 
 void CefTextfieldImpl::ClearEditHistory() {
diff --git a/libcef/browser/views/textfield_view.cc b/libcef/browser/views/textfield_view.cc
index 4029f87de..103d108ae 100644
--- a/libcef/browser/views/textfield_view.cc
+++ b/libcef/browser/views/textfield_view.cc
@@ -22,18 +22,21 @@ bool CefTextfieldView::HandleKeyEvent(views::Textfield* sender,
                                       const ui::KeyEvent& key_event) {
   DCHECK_EQ(sender, this);
 
-  if (!cef_delegate())
+  if (!cef_delegate()) {
     return false;
+  }
 
   CefKeyEvent cef_key_event;
-  if (!browser_util::GetCefKeyEvent(key_event, cef_key_event))
+  if (!browser_util::GetCefKeyEvent(key_event, cef_key_event)) {
     return false;
+  }
 
   return cef_delegate()->OnKeyEvent(GetCefTextfield(), cef_key_event);
 }
 
 void CefTextfieldView::OnAfterUserAction(views::Textfield* sender) {
   DCHECK_EQ(sender, this);
-  if (cef_delegate())
+  if (cef_delegate()) {
     cef_delegate()->OnAfterUserAction(GetCefTextfield());
+  }
 }
diff --git a/libcef/browser/views/view_adapter.cc b/libcef/browser/views/view_adapter.cc
index 4dfbd482d..5c3257380 100644
--- a/libcef/browser/views/view_adapter.cc
+++ b/libcef/browser/views/view_adapter.cc
@@ -53,7 +53,8 @@ CefViewAdapter* CefViewAdapter::GetFor(CefRefPtr<CefView> view) {
 // static
 CefViewAdapter* CefViewAdapter::GetFor(views::View* view) {
   CefRefPtr<CefView> cef_view = view_util::GetFor(view, false);
-  if (cef_view)
+  if (cef_view) {
     return GetFor(cef_view);
+  }
   return nullptr;
 }
diff --git a/libcef/browser/views/view_impl.h b/libcef/browser/views/view_impl.h
index 502696202..dc3266f54 100644
--- a/libcef/browser/views/view_impl.h
+++ b/libcef/browser/views/view_impl.h
@@ -338,8 +338,9 @@ CEF_VIEW_IMPL_T class CefViewImpl : public CefViewAdapter, public CefViewClass {
     root_view_.reset(root_view_ref_);
   }
   void Detach() override {
-    if (root_view_)
+    if (root_view_) {
       root_view_.reset();
+    }
     root_view_ref_ = nullptr;
   }
   void GetDebugInfo(base::DictionaryValue* info,
@@ -454,10 +455,11 @@ CEF_VIEW_IMPL_T CefString CEF_VIEW_IMPL_D::GetTypeString() {
 CEF_VIEW_IMPL_T CefString CEF_VIEW_IMPL_D::ToString(bool include_children) {
   CEF_REQUIRE_UIT_RETURN(CefString());
   std::unique_ptr<base::DictionaryValue> info(new base::DictionaryValue());
-  if (IsValid())
+  if (IsValid()) {
     GetDebugInfo(info.get(), include_children);
-  else
+  } else {
     info->SetString("type", GetDebugType());
+  }
 
   std::string json_string;
   base::JSONWriter::WriteWithOptions(*info, 0, &json_string);
@@ -477,8 +479,9 @@ CEF_VIEW_IMPL_T bool CEF_VIEW_IMPL_D::IsAttached() {
 CEF_VIEW_IMPL_T bool CEF_VIEW_IMPL_D::IsSame(CefRefPtr<CefView> that) {
   CEF_REQUIRE_UIT_RETURN(false);
   CefViewImpl* that_impl = static_cast<CefViewImpl*>(that.get());
-  if (!that_impl)
+  if (!that_impl) {
     return false;
+  }
   return this == that_impl;
 }
 
@@ -489,8 +492,9 @@ CEF_VIEW_IMPL_T CefRefPtr<CefViewDelegate> CEF_VIEW_IMPL_D::GetDelegate() {
 
 CEF_VIEW_IMPL_T CefRefPtr<CefWindow> CEF_VIEW_IMPL_D::GetWindow() {
   CEF_REQUIRE_UIT_RETURN(nullptr);
-  if (root_view())
+  if (root_view()) {
     return view_util::GetWindowFor(root_view()->GetWidget());
+  }
   return nullptr;
 }
 
@@ -511,24 +515,27 @@ CEF_VIEW_IMPL_T int CEF_VIEW_IMPL_D::GetGroupID() {
 
 CEF_VIEW_IMPL_T void CEF_VIEW_IMPL_D::SetGroupID(int group_id) {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (root_view()->GetGroup() != -1)
+  if (root_view()->GetGroup() != -1) {
     return;
+  }
   root_view()->SetGroup(group_id);
 }
 
 CEF_VIEW_IMPL_T CefRefPtr<CefView> CEF_VIEW_IMPL_D::GetParentView() {
   CEF_REQUIRE_VALID_RETURN(nullptr);
   views::View* view = root_view()->parent();
-  if (!view)
+  if (!view) {
     return nullptr;
+  }
   return view_util::GetFor(view, true);
 }
 
 CEF_VIEW_IMPL_T CefRefPtr<CefView> CEF_VIEW_IMPL_D::GetViewForID(int id) {
   CEF_REQUIRE_VALID_RETURN(nullptr);
   views::View* view = root_view()->GetViewByID(id);
-  if (!view)
+  if (!view) {
     return nullptr;
+  }
   return view_util::GetFor(view, true);
 }
 
@@ -681,8 +688,9 @@ CEF_VIEW_IMPL_T cef_color_t CEF_VIEW_IMPL_D::GetBackgroundColor() {
 CEF_VIEW_IMPL_T bool CEF_VIEW_IMPL_D::ConvertPointToScreen(CefPoint& point) {
   CEF_REQUIRE_VALID_RETURN(false);
   gfx::Point gfx_point = gfx::Point(point.x, point.y);
-  if (!view_util::ConvertPointToScreen(root_view(), &gfx_point, false))
+  if (!view_util::ConvertPointToScreen(root_view(), &gfx_point, false)) {
     return false;
+  }
   point = CefPoint(gfx_point.x(), gfx_point.y());
   return true;
 }
@@ -690,8 +698,9 @@ CEF_VIEW_IMPL_T bool CEF_VIEW_IMPL_D::ConvertPointToScreen(CefPoint& point) {
 CEF_VIEW_IMPL_T bool CEF_VIEW_IMPL_D::ConvertPointFromScreen(CefPoint& point) {
   CEF_REQUIRE_VALID_RETURN(false);
   gfx::Point gfx_point = gfx::Point(point.x, point.y);
-  if (!view_util::ConvertPointFromScreen(root_view(), &gfx_point, false))
+  if (!view_util::ConvertPointFromScreen(root_view(), &gfx_point, false)) {
     return false;
+  }
   point = CefPoint(gfx_point.x(), gfx_point.y());
   return true;
 }
@@ -699,8 +708,9 @@ CEF_VIEW_IMPL_T bool CEF_VIEW_IMPL_D::ConvertPointFromScreen(CefPoint& point) {
 CEF_VIEW_IMPL_T bool CEF_VIEW_IMPL_D::ConvertPointToWindow(CefPoint& point) {
   CEF_REQUIRE_VALID_RETURN(false);
   gfx::Point gfx_point = gfx::Point(point.x, point.y);
-  if (!view_util::ConvertPointToWindow(root_view(), &gfx_point))
+  if (!view_util::ConvertPointToWindow(root_view(), &gfx_point)) {
     return false;
+  }
   point = CefPoint(gfx_point.x(), gfx_point.y());
   return true;
 }
@@ -708,8 +718,9 @@ CEF_VIEW_IMPL_T bool CEF_VIEW_IMPL_D::ConvertPointToWindow(CefPoint& point) {
 CEF_VIEW_IMPL_T bool CEF_VIEW_IMPL_D::ConvertPointFromWindow(CefPoint& point) {
   CEF_REQUIRE_VALID_RETURN(false);
   gfx::Point gfx_point = gfx::Point(point.x, point.y);
-  if (!view_util::ConvertPointFromWindow(root_view(), &gfx_point))
+  if (!view_util::ConvertPointFromWindow(root_view(), &gfx_point)) {
     return false;
+  }
   point = CefPoint(gfx_point.x(), gfx_point.y());
   return true;
 }
@@ -718,11 +729,13 @@ CEF_VIEW_IMPL_T bool CEF_VIEW_IMPL_D::ConvertPointToView(
     CefRefPtr<CefView> view,
     CefPoint& point) {
   CEF_REQUIRE_VALID_RETURN(false);
-  if (!root_view()->GetWidget())
+  if (!root_view()->GetWidget()) {
     return false;
+  }
   views::View* target_view = view_util::GetFor(view);
-  if (!target_view || target_view->GetWidget() != root_view()->GetWidget())
+  if (!target_view || target_view->GetWidget() != root_view()->GetWidget()) {
     return false;
+  }
   gfx::Point gfx_point = gfx::Point(point.x, point.y);
   views::View::ConvertPointToTarget(root_view(), target_view, &gfx_point);
   point = CefPoint(gfx_point.x(), gfx_point.y());
@@ -733,11 +746,13 @@ CEF_VIEW_IMPL_T bool CEF_VIEW_IMPL_D::ConvertPointFromView(
     CefRefPtr<CefView> view,
     CefPoint& point) {
   CEF_REQUIRE_VALID_RETURN(false);
-  if (!root_view()->GetWidget())
+  if (!root_view()->GetWidget()) {
     return false;
+  }
   views::View* target_view = view_util::GetFor(view);
-  if (!target_view || target_view->GetWidget() != root_view()->GetWidget())
+  if (!target_view || target_view->GetWidget() != root_view()->GetWidget()) {
     return false;
+  }
   gfx::Point gfx_point = gfx::Point(point.x, point.y);
   views::View::ConvertPointToTarget(target_view, root_view(), &gfx_point);
   point = CefPoint(gfx_point.x(), gfx_point.y());
diff --git a/libcef/browser/views/view_util.cc b/libcef/browser/views/view_util.cc
index 6113f0d69..5283f48c0 100644
--- a/libcef/browser/views/view_util.cc
+++ b/libcef/browser/views/view_util.cc
@@ -50,8 +50,9 @@ class UserData : public base::SupportsUserData::Data {
   static CefRefPtr<CefView> GetFor(const views::View* view) {
     DCHECK(view);
     UserData* data = static_cast<UserData*>(view->GetUserData(UserDataKey()));
-    if (data)
+    if (data) {
       return data->view_ref_;
+    }
     return nullptr;
   }
 
@@ -132,18 +133,21 @@ void Register(CefRefPtr<CefView> view) {
 }
 
 CefRefPtr<CefView> GetFor(const views::View* view, bool find_known_parent) {
-  if (!view)
+  if (!view) {
     return nullptr;
+  }
 
-  if (!find_known_parent)
+  if (!find_known_parent) {
     return UserData::GetFor(view);
+  }
 
   CefRefPtr<CefView> cef_view;
   const views::View* current_view = view;
   do {
     cef_view = UserData::GetFor(current_view);
-    if (cef_view)
+    if (cef_view) {
       break;
+    }
     current_view = current_view->parent();
   } while (current_view);
 
@@ -183,8 +187,9 @@ CefRefPtr<CefWindow> GetWindowFor(views::Widget* widget) {
     // was created by something else let's go about this the safer way.
     views::View* content_view = widget->widget_delegate()->GetContentsView();
     CefRefPtr<CefView> cef_view = GetFor(content_view, false);
-    if (cef_view && cef_view->AsPanel())
+    if (cef_view && cef_view->AsPanel()) {
       window = cef_view->AsPanel()->AsWindow();
+    }
 
     // The Window should always exist if we created the views::Widget.
     DCHECK(window);
@@ -249,8 +254,9 @@ gfx::Rect ConvertRectToPixels(const gfx::Rect& rect) {
 bool ConvertPointToScreen(views::View* view,
                           gfx::Point* point,
                           bool output_pixel_coords) {
-  if (!view->GetWidget())
+  if (!view->GetWidget()) {
     return false;
+  }
 
   views::View::ConvertPointToScreen(view, point);
 
@@ -265,8 +271,9 @@ bool ConvertPointToScreen(views::View* view,
 bool ConvertPointFromScreen(views::View* view,
                             gfx::Point* point,
                             bool input_pixel_coords) {
-  if (!view->GetWidget())
+  if (!view->GetWidget()) {
     return false;
+  }
 
   if (input_pixel_coords) {
     const display::Display& display = GetDisplayNearestPoint(*point, true);
@@ -280,8 +287,9 @@ bool ConvertPointFromScreen(views::View* view,
 
 bool ConvertPointToWindow(views::View* view, gfx::Point* point) {
   views::Widget* widget = view->GetWidget();
-  if (!widget)
+  if (!widget) {
     return false;
+  }
 
   views::View::ConvertPointToWidget(view, point);
 
@@ -303,8 +311,9 @@ bool ConvertPointToWindow(views::View* view, gfx::Point* point) {
 
 bool ConvertPointFromWindow(views::View* view, gfx::Point* point) {
   views::Widget* widget = view->GetWidget();
-  if (!widget)
+  if (!widget) {
     return false;
+  }
 
   if (widget->non_client_view()) {
     views::NonClientFrameView* non_client_frame_view =
diff --git a/libcef/browser/views/view_util_aura.cc b/libcef/browser/views/view_util_aura.cc
index 8a144eb33..5ff60bd7c 100644
--- a/libcef/browser/views/view_util_aura.cc
+++ b/libcef/browser/views/view_util_aura.cc
@@ -13,8 +13,9 @@ namespace view_util {
 gfx::NativeWindow GetNativeWindow(views::Widget* widget) {
   if (widget) {
     aura::Window* window = widget->GetNativeWindow();
-    if (window)
+    if (window) {
       return window->GetRootWindow();
+    }
   }
   return nullptr;
 }
diff --git a/libcef/browser/views/view_util_mac.mm b/libcef/browser/views/view_util_mac.mm
index 16983e018..8320b477d 100644
--- a/libcef/browser/views/view_util_mac.mm
+++ b/libcef/browser/views/view_util_mac.mm
@@ -13,22 +13,25 @@
 namespace view_util {
 
 gfx::NativeWindow GetNativeWindow(views::Widget* widget) {
-  if (widget)
+  if (widget) {
     return widget->GetNativeWindow();
+  }
   return gfx::NativeWindow();
 }
 
 gfx::NativeView GetNativeView(views::Widget* widget) {
-  if (widget)
+  if (widget) {
     return widget->GetNativeView();
+  }
   return gfx::NativeView();
 }
 
 CefWindowHandle GetWindowHandle(views::Widget* widget) {
   // |view| is a wrapper type from native_widget_types.h.
   auto view = GetNativeView(widget);
-  if (view)
+  if (view) {
     return CAST_NSVIEW_TO_CEF_WINDOW_HANDLE(view.GetNativeNSView());
+  }
   return kNullWindowHandle;
 }
 
diff --git a/libcef/browser/views/view_view.h b/libcef/browser/views/view_view.h
index 1e2fbd0e6..23e669656 100644
--- a/libcef/browser/views/view_view.h
+++ b/libcef/browser/views/view_view.h
@@ -99,11 +99,13 @@ CEF_VIEW_VIEW_T gfx::Size CEF_VIEW_VIEW_D::CalculatePreferredSize() const {
   gfx::Size result;
   if (cef_delegate()) {
     CefSize cef_size = cef_delegate()->GetPreferredSize(GetCefView());
-    if (!cef_size.IsEmpty())
+    if (!cef_size.IsEmpty()) {
       result = gfx::Size(cef_size.width, cef_size.height);
+    }
   }
-  if (result.IsEmpty())
+  if (result.IsEmpty()) {
     result = ParentClass::CalculatePreferredSize();
+  }
   if (result.IsEmpty()) {
     // Some layouts like BoxLayout expect the preferred size to be non-empty.
     // The user may have set the size explicitly. Therefore return the current
@@ -117,14 +119,16 @@ CEF_VIEW_VIEW_T gfx::Size CEF_VIEW_VIEW_D::GetMinimumSize() const {
   gfx::Size result;
   if (cef_delegate()) {
     CefSize cef_size = cef_delegate()->GetMinimumSize(GetCefView());
-    if (!cef_size.IsEmpty())
+    if (!cef_size.IsEmpty()) {
       result = gfx::Size(cef_size.width, cef_size.height);
+    }
   }
   // We don't want to call ParentClass::GetMinimumSize() in all cases because
   // the default views::View implementation will call GetPreferredSize(). That
   // may result in size() being returned which keeps the View from shrinking.
-  if (result.IsEmpty() && HasMinimumSize())
+  if (result.IsEmpty() && HasMinimumSize()) {
     result = ParentClass::GetMinimumSize();
+  }
   return result;
 }
 
@@ -132,20 +136,24 @@ CEF_VIEW_VIEW_T gfx::Size CEF_VIEW_VIEW_D::GetMaximumSize() const {
   gfx::Size result;
   if (cef_delegate()) {
     CefSize cef_size = cef_delegate()->GetMaximumSize(GetCefView());
-    if (!cef_size.IsEmpty())
+    if (!cef_size.IsEmpty()) {
       result = gfx::Size(cef_size.width, cef_size.height);
+    }
   }
-  if (result.IsEmpty())
+  if (result.IsEmpty()) {
     result = ParentClass::GetMaximumSize();
+  }
   return result;
 }
 
 CEF_VIEW_VIEW_T int CEF_VIEW_VIEW_D::GetHeightForWidth(int w) const {
   int result = 0;
-  if (cef_delegate())
+  if (cef_delegate()) {
     result = cef_delegate()->GetHeightForWidth(GetCefView(), w);
-  if (result == 0)
+  }
+  if (result == 0) {
     result = ParentClass::GetHeightForWidth(w);
+  }
   if (result == 0) {
     // Some layouts like FillLayout will ignore the preferred size if this view
     // has no children. We want to use the preferred size if not otherwise
@@ -159,8 +167,9 @@ CEF_VIEW_VIEW_T void CEF_VIEW_VIEW_D::Layout() {
   ParentClass::Layout();
 
   // If Layout() did not provide a size then use the preferred size.
-  if (ParentClass::size().IsEmpty())
+  if (ParentClass::size().IsEmpty()) {
     ParentClass::SizeToPreferredSize();
+  }
 
   if (cef_delegate()) {
     const auto new_bounds = ParentClass::bounds();
@@ -179,37 +188,43 @@ CEF_VIEW_VIEW_T void CEF_VIEW_VIEW_D::ViewHierarchyChanged(
 
 CEF_VIEW_VIEW_T void CEF_VIEW_VIEW_D::AddedToWidget() {
   ParentClass::AddedToWidget();
-  if (cef_delegate())
+  if (cef_delegate()) {
     cef_delegate()->OnWindowChanged(GetCefView(), /*added=*/true);
+  }
 }
 
 CEF_VIEW_VIEW_T void CEF_VIEW_VIEW_D::RemovedFromWidget() {
-  if (cef_delegate())
+  if (cef_delegate()) {
     cef_delegate()->OnWindowChanged(GetCefView(), /*added=*/false);
+  }
   ParentClass::RemovedFromWidget();
 }
 
 CEF_VIEW_VIEW_T void CEF_VIEW_VIEW_D::OnFocus() {
-  if (cef_delegate())
+  if (cef_delegate()) {
     cef_delegate()->OnFocus(GetCefView());
+  }
   ParentClass::OnFocus();
 }
 
 CEF_VIEW_VIEW_T void CEF_VIEW_VIEW_D::OnBlur() {
-  if (cef_delegate())
+  if (cef_delegate()) {
     cef_delegate()->OnBlur(GetCefView());
+  }
   ParentClass::OnBlur();
 }
 
 CEF_VIEW_VIEW_T void CEF_VIEW_VIEW_D::NotifyChildViewChanged(
     const views::ViewHierarchyChangedDetails& details) {
-  if (!cef_delegate())
+  if (!cef_delegate()) {
     return;
+  }
 
   // Only interested with the parent is |this| object and the notification is
   // about an immediate child (notifications are also sent for grandchildren).
-  if (details.parent != this || details.child->parent() != this)
+  if (details.parent != this || details.child->parent() != this) {
     return;
+  }
 
   // Only notify for children that have a known CEF root view. For example,
   // don't notify when ScrollView adds child scroll bars.
@@ -221,13 +236,15 @@ CEF_VIEW_VIEW_T void CEF_VIEW_VIEW_D::NotifyChildViewChanged(
 
 CEF_VIEW_VIEW_T void CEF_VIEW_VIEW_D::NotifyParentViewChanged(
     const views::ViewHierarchyChangedDetails& details) {
-  if (!cef_delegate())
+  if (!cef_delegate()) {
     return;
+  }
 
   // Only interested when the child is |this| object and notification is about
   // the immediate parent (notifications are sent for all parents).
-  if (details.child != this || details.parent != ParentClass::parent())
+  if (details.child != this || details.parent != ParentClass::parent()) {
     return;
+  }
 
   // The immediate parent might be an intermediate view so find the closest
   // known CEF root view. |parent| might be nullptr for overlays.
diff --git a/libcef/browser/views/window_impl.cc b/libcef/browser/views/window_impl.cc
index 665d57f61..e86de6506 100644
--- a/libcef/browser/views/window_impl.cc
+++ b/libcef/browser/views/window_impl.cc
@@ -123,33 +123,38 @@ CefRefPtr<CefWindowImpl> CefWindowImpl::Create(
   CefRefPtr<CefWindowImpl> window = new CefWindowImpl(delegate);
   window->Initialize();
   window->CreateWidget(parent_widget);
-  if (delegate)
+  if (delegate) {
     delegate->OnWindowCreated(window.get());
+  }
   return window;
 }
 
 void CefWindowImpl::Show() {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (widget_)
+  if (widget_) {
     widget_->Show();
+  }
 }
 
 void CefWindowImpl::Hide() {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (widget_)
+  if (widget_) {
     widget_->Hide();
+  }
 }
 
 void CefWindowImpl::CenterWindow(const CefSize& size) {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (widget_)
+  if (widget_) {
     widget_->CenterWindow(gfx::Size(size.width, size.height));
+  }
 }
 
 void CefWindowImpl::Close() {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (widget_ && !widget_->IsClosed())
+  if (widget_ && !widget_->IsClosed()) {
     widget_->Close();
+  }
 }
 
 bool CefWindowImpl::IsClosed() {
@@ -159,27 +164,31 @@ bool CefWindowImpl::IsClosed() {
 
 void CefWindowImpl::Activate() {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (widget_ && widget_->CanActivate() && !widget_->IsActive())
+  if (widget_ && widget_->CanActivate() && !widget_->IsActive()) {
     widget_->Activate();
+  }
 }
 
 void CefWindowImpl::Deactivate() {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (widget_ && widget_->CanActivate() && widget_->IsActive())
+  if (widget_ && widget_->CanActivate() && widget_->IsActive()) {
     widget_->Deactivate();
+  }
 }
 
 bool CefWindowImpl::IsActive() {
   CEF_REQUIRE_VALID_RETURN(false);
-  if (widget_)
+  if (widget_) {
     return widget_->IsActive();
+  }
   return false;
 }
 
 void CefWindowImpl::BringToTop() {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (widget_)
+  if (widget_) {
     widget_->StackAtTop();
+  }
 }
 
 void CefWindowImpl::SetAlwaysOnTop(bool on_top) {
@@ -193,92 +202,106 @@ void CefWindowImpl::SetAlwaysOnTop(bool on_top) {
 
 bool CefWindowImpl::IsAlwaysOnTop() {
   CEF_REQUIRE_VALID_RETURN(false);
-  if (widget_)
+  if (widget_) {
     return widget_->GetZOrderLevel() == ui::ZOrderLevel::kFloatingWindow;
+  }
   return false;
 }
 
 void CefWindowImpl::Maximize() {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (widget_ && !widget_->IsMaximized())
+  if (widget_ && !widget_->IsMaximized()) {
     widget_->Maximize();
+  }
 }
 
 void CefWindowImpl::Minimize() {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (widget_ && !widget_->IsMinimized())
+  if (widget_ && !widget_->IsMinimized()) {
     widget_->Minimize();
+  }
 }
 
 void CefWindowImpl::Restore() {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (widget_ && (widget_->IsMaximized() || widget_->IsMinimized()))
+  if (widget_ && (widget_->IsMaximized() || widget_->IsMinimized())) {
     widget_->Restore();
+  }
 }
 
 void CefWindowImpl::SetFullscreen(bool fullscreen) {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (widget_ && fullscreen != widget_->IsFullscreen())
+  if (widget_ && fullscreen != widget_->IsFullscreen()) {
     widget_->SetFullscreen(fullscreen);
+  }
 }
 
 bool CefWindowImpl::IsMaximized() {
   CEF_REQUIRE_VALID_RETURN(false);
-  if (widget_)
+  if (widget_) {
     return widget_->IsMaximized();
+  }
   return false;
 }
 
 bool CefWindowImpl::IsMinimized() {
   CEF_REQUIRE_VALID_RETURN(false);
-  if (widget_)
+  if (widget_) {
     return widget_->IsMinimized();
+  }
   return false;
 }
 
 bool CefWindowImpl::IsFullscreen() {
   CEF_REQUIRE_VALID_RETURN(false);
-  if (widget_)
+  if (widget_) {
     return widget_->IsFullscreen();
+  }
   return false;
 }
 
 void CefWindowImpl::SetTitle(const CefString& title) {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (root_view())
+  if (root_view()) {
     root_view()->SetTitle(title);
+  }
 }
 
 CefString CefWindowImpl::GetTitle() {
   CEF_REQUIRE_VALID_RETURN(CefString());
-  if (root_view())
+  if (root_view()) {
     return root_view()->title();
+  }
   return CefString();
 }
 
 void CefWindowImpl::SetWindowIcon(CefRefPtr<CefImage> image) {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (root_view())
+  if (root_view()) {
     root_view()->SetWindowIcon(image);
+  }
 }
 
 CefRefPtr<CefImage> CefWindowImpl::GetWindowIcon() {
   CEF_REQUIRE_VALID_RETURN(nullptr);
-  if (root_view())
+  if (root_view()) {
     return root_view()->window_icon();
+  }
   return nullptr;
 }
 
 void CefWindowImpl::SetWindowAppIcon(CefRefPtr<CefImage> image) {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (root_view())
+  if (root_view()) {
     root_view()->SetWindowAppIcon(image);
+  }
 }
 
 CefRefPtr<CefImage> CefWindowImpl::GetWindowAppIcon() {
   CEF_REQUIRE_VALID_RETURN(nullptr);
-  if (root_view())
+  if (root_view()) {
     return root_view()->window_app_icon();
+  }
   return nullptr;
 }
 
@@ -286,16 +309,18 @@ CefRefPtr<CefOverlayController> CefWindowImpl::AddOverlayView(
     CefRefPtr<CefView> view,
     cef_docking_mode_t docking_mode) {
   CEF_REQUIRE_VALID_RETURN(nullptr);
-  if (root_view())
+  if (root_view()) {
     return root_view()->AddOverlayView(view, docking_mode);
+  }
   return nullptr;
 }
 
 void CefWindowImpl::GetDebugInfo(base::DictionaryValue* info,
                                  bool include_children) {
   ParentClass::GetDebugInfo(info, include_children);
-  if (root_view())
+  if (root_view()) {
     info->SetString("title", root_view()->title());
+  }
 }
 
 void CefWindowImpl::ShowMenu(CefRefPtr<CefMenuModel> menu_model,
@@ -322,8 +347,9 @@ void CefWindowImpl::SetBounds(const CefRect& bounds) {
 CefRect CefWindowImpl::GetBounds() {
   CEF_REQUIRE_VALID_RETURN(CefRect());
   gfx::Rect bounds;
-  if (widget_)
+  if (widget_) {
     bounds = widget_->GetWindowBoundsInScreen();
+  }
   return CefRect(bounds.x(), bounds.y(), bounds.width(), bounds.height());
 }
 
@@ -333,8 +359,9 @@ CefRect CefWindowImpl::GetBoundsInScreen() {
 
 void CefWindowImpl::SetSize(const CefSize& size) {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (widget_)
+  if (widget_) {
     widget_->SetSize(gfx::Size(size.width, size.height));
+  }
 }
 
 void CefWindowImpl::SetPosition(const CefPoint& position) {
@@ -349,24 +376,27 @@ void CefWindowImpl::SetPosition(const CefPoint& position) {
 void CefWindowImpl::SizeToPreferredSize() {
   CEF_REQUIRE_VALID_RETURN_VOID();
   if (widget_) {
-    if (widget_->non_client_view())
+    if (widget_->non_client_view()) {
       widget_->SetSize(widget_->non_client_view()->GetPreferredSize());
-    else
+    } else {
       widget_->SetSize(root_view()->GetPreferredSize());
+    }
   }
 }
 
 void CefWindowImpl::SetVisible(bool visible) {
-  if (visible)
+  if (visible) {
     Show();
-  else
+  } else {
     Hide();
+  }
 }
 
 bool CefWindowImpl::IsVisible() {
   CEF_REQUIRE_VALID_RETURN(false);
-  if (widget_)
+  if (widget_) {
     return widget_->IsVisible();
+  }
   return false;
 }
 
@@ -377,13 +407,15 @@ bool CefWindowImpl::IsDrawn() {
 void CefWindowImpl::SetBackgroundColor(cef_color_t color) {
   CEF_REQUIRE_VALID_RETURN_VOID();
   ParentClass::SetBackgroundColor(color);
-  if (widget_ && widget_->GetCompositor())
+  if (widget_ && widget_->GetCompositor()) {
     widget_->GetCompositor()->SetBackgroundColor(color);
+  }
 }
 
 bool CefWindowImpl::CanWidgetClose() {
-  if (delegate())
+  if (delegate()) {
     return delegate()->CanClose(this);
+  }
   return true;
 }
 
@@ -392,8 +424,9 @@ void CefWindowImpl::OnWindowClosing() {
   unhandled_key_event_handler_.reset();
 #endif
 
-  if (delegate())
+  if (delegate()) {
     delegate()->OnWindowClosing(this);
+  }
 }
 
 void CefWindowImpl::OnWindowViewDeleted() {
@@ -402,8 +435,9 @@ void CefWindowImpl::OnWindowViewDeleted() {
   destroyed_ = true;
   widget_ = nullptr;
 
-  if (delegate())
+  if (delegate()) {
     delegate()->OnWindowDestroyed(this);
+  }
 
   // Call Detach() here instead of waiting for the root View to be deleted so
   // that any following attempts to call CefWindow methods from the delegate
@@ -414,21 +448,24 @@ void CefWindowImpl::OnWindowViewDeleted() {
 // Will only be called if CanHandleAccelerators() returns true.
 bool CefWindowImpl::AcceleratorPressed(const ui::Accelerator& accelerator) {
   for (const auto& entry : accelerator_map_) {
-    if (entry.second == accelerator)
+    if (entry.second == accelerator) {
       return delegate()->OnAccelerator(this, entry.first);
+    }
   }
   return false;
 }
 
 bool CefWindowImpl::CanHandleAccelerators() const {
-  if (delegate() && widget_)
+  if (delegate() && widget_) {
     return widget_->IsActive();
+  }
   return false;
 }
 
 bool CefWindowImpl::OnKeyEvent(const CefKeyEvent& event) {
-  if (delegate())
+  if (delegate()) {
     return delegate()->OnKeyEvent(this, event);
+  }
   return false;
 }
 
@@ -438,13 +475,15 @@ void CefWindowImpl::ShowMenu(views::MenuButton* menu_button,
                              cef_menu_anchor_position_t anchor_position) {
   CancelMenu();
 
-  if (!widget_)
+  if (!widget_) {
     return;
+  }
 
   CefMenuModelImpl* menu_model_impl =
       static_cast<CefMenuModelImpl*>(menu_model.get());
-  if (!menu_model_impl || !menu_model_impl->model())
+  if (!menu_model_impl || !menu_model_impl->model()) {
     return;
+  }
 
   menu_model_ = menu_model_impl;
 
@@ -472,8 +511,9 @@ void CefWindowImpl::MenuClosed() {
 
 void CefWindowImpl::CancelMenu() {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (menu_runner_)
+  if (menu_runner_) {
     menu_runner_->Cancel();
+  }
   DCHECK(!menu_model_);
   DCHECK(!menu_runner_);
 }
@@ -482,8 +522,9 @@ CefRefPtr<CefDisplay> CefWindowImpl::GetDisplay() {
   CEF_REQUIRE_VALID_RETURN(nullptr);
   if (widget_ && root_view()) {
     const display::Display& display = root_view()->GetDisplay();
-    if (display.is_valid())
+    if (display.is_valid()) {
       return new CefDisplayImpl(display);
+    }
   }
   return nullptr;
 }
@@ -513,8 +554,9 @@ CefRect CefWindowImpl::GetClientAreaBoundsInScreen() {
 void CefWindowImpl::SetDraggableRegions(
     const std::vector<CefDraggableRegion>& regions) {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (root_view())
+  if (root_view()) {
     root_view()->SetDraggableRegions(regions);
+  }
 }
 
 CefWindowHandle CefWindowImpl::GetWindowHandle() {
@@ -527,8 +569,9 @@ void CefWindowImpl::SendKeyPress(int key_code, uint32 event_flags) {
   InitializeUITesting();
 
   gfx::NativeWindow native_window = view_util::GetNativeWindow(widget_);
-  if (!native_window)
+  if (!native_window) {
     return;
+  }
 
   ui_controls::SendKeyPress(native_window,
                             static_cast<ui::KeyboardCode>(key_code),
@@ -551,22 +594,26 @@ void CefWindowImpl::SendMouseEvents(cef_mouse_button_type_t button,
                                     bool mouse_down,
                                     bool mouse_up) {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (!mouse_down && !mouse_up)
+  if (!mouse_down && !mouse_up) {
     return;
+  }
 
   InitializeUITesting();
 
   ui_controls::MouseButton type = ui_controls::LEFT;
-  if (button == MBT_MIDDLE)
+  if (button == MBT_MIDDLE) {
     type = ui_controls::MIDDLE;
-  else if (button == MBT_RIGHT)
+  } else if (button == MBT_RIGHT) {
     type = ui_controls::RIGHT;
+  }
 
   int state = 0;
-  if (mouse_down)
+  if (mouse_down) {
     state |= ui_controls::DOWN;
-  if (mouse_up)
+  }
+  if (mouse_up) {
     state |= ui_controls::UP;
+  }
 
   ui_controls::SendMouseEvents(type, state);
 }
@@ -577,20 +624,25 @@ void CefWindowImpl::SetAccelerator(int command_id,
                                    bool ctrl_pressed,
                                    bool alt_pressed) {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (!widget_)
+  if (!widget_) {
     return;
+  }
 
   AcceleratorMap::const_iterator it = accelerator_map_.find(command_id);
-  if (it != accelerator_map_.end())
+  if (it != accelerator_map_.end()) {
     RemoveAccelerator(command_id);
+  }
 
   int modifiers = 0;
-  if (shift_pressed)
+  if (shift_pressed) {
     modifiers |= ui::EF_SHIFT_DOWN;
-  if (ctrl_pressed)
+  }
+  if (ctrl_pressed) {
     modifiers |= ui::EF_CONTROL_DOWN;
-  if (alt_pressed)
+  }
+  if (alt_pressed) {
     modifiers |= ui::EF_ALT_DOWN;
+  }
   ui::Accelerator accelerator(static_cast<ui::KeyboardCode>(key_code),
                               modifiers);
 
@@ -604,12 +656,14 @@ void CefWindowImpl::SetAccelerator(int command_id,
 
 void CefWindowImpl::RemoveAccelerator(int command_id) {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (!widget_)
+  if (!widget_) {
     return;
+  }
 
   AcceleratorMap::iterator it = accelerator_map_.find(command_id);
-  if (it == accelerator_map_.end())
+  if (it == accelerator_map_.end()) {
     return;
+  }
 
   ui::Accelerator accelerator = it->second;
 
@@ -622,8 +676,9 @@ void CefWindowImpl::RemoveAccelerator(int command_id) {
 
 void CefWindowImpl::RemoveAllAccelerators() {
   CEF_REQUIRE_VALID_RETURN_VOID();
-  if (!widget_)
+  if (!widget_) {
     return;
+  }
 
   accelerator_map_.clear();
 
diff --git a/libcef/browser/views/window_view.cc b/libcef/browser/views/window_view.cc
index 1e8d58a32..93b98275b 100644
--- a/libcef/browser/views/window_view.cc
+++ b/libcef/browser/views/window_view.cc
@@ -85,13 +85,15 @@ class NativeFrameViewEx : public views::NativeFrameView {
   }
 
   int NonClientHitTest(const gfx::Point& point) override {
-    if (widget_->IsFullscreen())
+    if (widget_->IsFullscreen()) {
       return HTCLIENT;
+    }
 
     // Test for mouse clicks that fall within the draggable region.
     SkRegion* draggable_region = view_->draggable_region();
-    if (draggable_region && draggable_region->contains(point.x(), point.y()))
+    if (draggable_region && draggable_region->contains(point.x(), point.y())) {
       return HTCAPTION;
+    }
 
     return views::NativeFrameView::NonClientHitTest(point);
   }
@@ -130,12 +132,14 @@ class CaptionlessFrameView : public views::NonClientFrameView {
   }
 
   int NonClientHitTest(const gfx::Point& point) override {
-    if (widget_->IsFullscreen())
+    if (widget_->IsFullscreen()) {
       return HTCLIENT;
+    }
 
     // Sanity check.
-    if (!bounds().Contains(point))
+    if (!bounds().Contains(point)) {
       return HTNOWHERE;
+    }
 
     // Check the frame first, as we allow a small area overlapping the contents
     // to be used for resize handles.
@@ -149,17 +153,20 @@ class CaptionlessFrameView : public views::NonClientFrameView {
         point,
         gfx::Insets::VH(resize_border_thickness, resize_border_thickness),
         kResizeAreaCornerSize, kResizeAreaCornerSize, can_ever_resize);
-    if (frame_component != HTNOWHERE)
+    if (frame_component != HTNOWHERE) {
       return frame_component;
+    }
 
     // Test for mouse clicks that fall within the draggable region.
     SkRegion* draggable_region = view_->draggable_region();
-    if (draggable_region && draggable_region->contains(point.x(), point.y()))
+    if (draggable_region && draggable_region->contains(point.x(), point.y())) {
       return HTCAPTION;
+    }
 
     int client_component = widget_->client_view()->NonClientHitTest(point);
-    if (client_component != HTNOWHERE)
+    if (client_component != HTNOWHERE) {
       return client_component;
+    }
 
     // Caption is a safe default.
     return HTCAPTION;
@@ -407,14 +414,16 @@ void CefWindowView::DeleteDelegate() {
 }
 
 bool CefWindowView::CanMinimize() const {
-  if (!cef_delegate())
+  if (!cef_delegate()) {
     return true;
+  }
   return cef_delegate()->CanMinimize(GetCefWindow());
 }
 
 bool CefWindowView::CanMaximize() const {
-  if (!cef_delegate())
+  if (!cef_delegate()) {
     return true;
+  }
   return cef_delegate()->CanMaximize(GetCefWindow());
 }
 
@@ -423,8 +432,9 @@ std::u16string CefWindowView::GetWindowTitle() const {
 }
 
 ui::ImageModel CefWindowView::GetWindowIcon() {
-  if (!window_icon_)
+  if (!window_icon_) {
     return ParentClass::GetWindowIcon();
+  }
   auto image_skia =
       static_cast<CefImageImpl*>(window_icon_.get())
           ->GetForced1xScaleRepresentation(GetDisplay().device_scale_factor());
@@ -432,8 +442,9 @@ ui::ImageModel CefWindowView::GetWindowIcon() {
 }
 
 ui::ImageModel CefWindowView::GetWindowAppIcon() {
-  if (!window_app_icon_)
+  if (!window_app_icon_) {
     return ParentClass::GetWindowAppIcon();
+  }
   auto image_skia =
       static_cast<CefImageImpl*>(window_app_icon_.get())
           ->GetForced1xScaleRepresentation(GetDisplay().device_scale_factor());
@@ -479,8 +490,9 @@ bool CefWindowView::ShouldDescendIntoChildForEventHandling(
     views::NonClientFrameView* ncfv = GetNonClientFrameView();
     if (ncfv) {
       int result = ncfv->NonClientHitTest(location);
-      if (IsWindowBorderHit(result))
+      if (IsWindowBorderHit(result)) {
         return false;
+      }
     }
   }
 
@@ -555,8 +567,9 @@ display::Display CefWindowView::GetDisplay() const {
 void CefWindowView::SetTitle(const std::u16string& title) {
   title_ = title;
   views::Widget* widget = GetWidget();
-  if (widget)
+  if (widget) {
     widget->UpdateWindowTitle();
+  }
 }
 
 void CefWindowView::SetWindowIcon(CefRefPtr<CefImage> window_icon) {
@@ -567,15 +580,17 @@ void CefWindowView::SetWindowIcon(CefRefPtr<CefImage> window_icon) {
 
   window_icon_ = window_icon;
   views::Widget* widget = GetWidget();
-  if (widget)
+  if (widget) {
     widget->UpdateWindowIcon();
+  }
 }
 
 void CefWindowView::SetWindowAppIcon(CefRefPtr<CefImage> window_app_icon) {
   window_app_icon_ = window_app_icon;
   views::Widget* widget = GetWidget();
-  if (widget)
+  if (widget) {
     widget->UpdateWindowIcon();
+  }
 }
 
 CefRefPtr<CefOverlayController> CefWindowView::AddOverlayView(
@@ -583,8 +598,9 @@ CefRefPtr<CefOverlayController> CefWindowView::AddOverlayView(
     cef_docking_mode_t docking_mode) {
   DCHECK(view.get());
   DCHECK(view->IsValid());
-  if (!view.get() || !view->IsValid())
+  if (!view.get() || !view->IsValid()) {
     return nullptr;
+  }
 
   views::Widget* widget = GetWidget();
   if (widget) {
@@ -604,8 +620,9 @@ CefRefPtr<CefOverlayController> CefWindowView::AddOverlayView(
 }
 
 void CefWindowView::MoveOverlaysIfNecessary() {
-  if (overlay_hosts_.empty())
+  if (overlay_hosts_.empty()) {
     return;
+  }
   for (auto& overlay_host : overlay_hosts_) {
     overlay_host->MoveIfNecessary();
   }
@@ -614,8 +631,9 @@ void CefWindowView::MoveOverlaysIfNecessary() {
 void CefWindowView::SetDraggableRegions(
     const std::vector<CefDraggableRegion>& regions) {
   if (regions.empty()) {
-    if (draggable_region_)
+    if (draggable_region_) {
       draggable_region_.reset(nullptr);
+    }
     return;
   }
 
@@ -631,9 +649,11 @@ void CefWindowView::SetDraggableRegions(
 
 views::NonClientFrameView* CefWindowView::GetNonClientFrameView() const {
   const views::Widget* widget = GetWidget();
-  if (!widget)
+  if (!widget) {
     return nullptr;
-  if (!widget->non_client_view())
+  }
+  if (!widget->non_client_view()) {
     return nullptr;
+  }
   return widget->non_client_view()->frame_view();
 }
diff --git a/libcef/browser/x509_cert_principal_impl.cc b/libcef/browser/x509_cert_principal_impl.cc
index 233447bf4..58922f023 100644
--- a/libcef/browser/x509_cert_principal_impl.cc
+++ b/libcef/browser/x509_cert_principal_impl.cc
@@ -8,13 +8,15 @@ namespace {
 
 void TransferVector(const std::vector<std::string>& source,
                     std::vector<CefString>& target) {
-  if (!target.empty())
+  if (!target.empty()) {
     target.clear();
+  }
 
   if (!source.empty()) {
     std::vector<std::string>::const_iterator it = source.begin();
-    for (; it != source.end(); ++it)
+    for (; it != source.end(); ++it) {
       target.push_back(*it);
+    }
   }
 }
 
diff --git a/libcef/browser/x509_certificate_impl.cc b/libcef/browser/x509_certificate_impl.cc
index 3acf39b1f..2aeb00bb3 100644
--- a/libcef/browser/x509_certificate_impl.cc
+++ b/libcef/browser/x509_certificate_impl.cc
@@ -21,8 +21,9 @@ CefRefPtr<CefBinaryValue> EncodeCertificate(const CRYPTO_BUFFER* cert_buffer,
   } else if (!net::X509Certificate::GetPEMEncoded(cert_buffer, &encoded)) {
     return nullptr;
   }
-  if (encoded.empty())
+  if (encoded.empty()) {
     return nullptr;
+  }
   return CefBinaryValue::Create(encoded.c_str(), encoded.size());
 }
 
@@ -37,14 +38,16 @@ CefX509CertificateImpl::CefX509CertificateImpl(
     : cert_(cert) {}
 
 CefRefPtr<CefX509CertPrincipal> CefX509CertificateImpl::GetSubject() {
-  if (cert_)
+  if (cert_) {
     return new CefX509CertPrincipalImpl(cert_->subject());
+  }
   return nullptr;
 }
 
 CefRefPtr<CefX509CertPrincipal> CefX509CertificateImpl::GetIssuer() {
-  if (cert_)
+  if (cert_) {
     return new CefX509CertPrincipalImpl(cert_->issuer());
+  }
   return nullptr;
 }
 
@@ -73,8 +76,9 @@ CefBaseTime CefX509CertificateImpl::GetValidExpiry() {
 CefRefPtr<CefBinaryValue> CefX509CertificateImpl::GetDEREncoded() {
   if (cert_) {
     const CRYPTO_BUFFER* cert_buffer = cert_->cert_buffer();
-    if (cert_buffer)
+    if (cert_buffer) {
       return EncodeCertificate(cert_buffer, true);
+    }
   }
   return nullptr;
 }
@@ -82,25 +86,28 @@ CefRefPtr<CefBinaryValue> CefX509CertificateImpl::GetDEREncoded() {
 CefRefPtr<CefBinaryValue> CefX509CertificateImpl::GetPEMEncoded() {
   if (cert_) {
     const CRYPTO_BUFFER* cert_buffer = cert_->cert_buffer();
-    if (cert_buffer)
+    if (cert_buffer) {
       return EncodeCertificate(cert_buffer, false);
+    }
   }
   return nullptr;
 }
 
 size_t CefX509CertificateImpl::GetIssuerChainSize() {
-  if (cert_)
+  if (cert_) {
     return cert_->intermediate_buffers().size();
+  }
   return 0;
 }
 
 void CefX509CertificateImpl::AcquirePrivateKey(
     base::OnceCallback<void(scoped_refptr<net::SSLPrivateKey>)>
         private_key_callback) {
-  if (identity_)
+  if (identity_) {
     identity_->AcquirePrivateKey(std::move(private_key_callback));
-  else
+  } else {
     std::move(private_key_callback).Run(nullptr);
+  }
 }
 
 void CefX509CertificateImpl::GetEncodedIssuerChain(
@@ -118,14 +125,16 @@ void CefX509CertificateImpl::GetEncodedIssuerChain(
 
 void CefX509CertificateImpl::GetDEREncodedIssuerChain(
     CefX509Certificate::IssuerChainBinaryList& chain) {
-  if (der_encoded_issuer_chain_.empty())
+  if (der_encoded_issuer_chain_.empty()) {
     GetEncodedIssuerChain(der_encoded_issuer_chain_, true);
+  }
   chain = der_encoded_issuer_chain_;
 }
 
 void CefX509CertificateImpl::GetPEMEncodedIssuerChain(
     CefX509Certificate::IssuerChainBinaryList& chain) {
-  if (pem_encoded_issuer_chain_.empty())
+  if (pem_encoded_issuer_chain_.empty()) {
     GetEncodedIssuerChain(pem_encoded_issuer_chain_, false);
+  }
   chain = pem_encoded_issuer_chain_;
 }
diff --git a/libcef/browser/xml_reader_impl.cc b/libcef/browser/xml_reader_impl.cc
index bfc4529ae..84455bf4e 100644
--- a/libcef/browser/xml_reader_impl.cc
+++ b/libcef/browser/xml_reader_impl.cc
@@ -16,8 +16,9 @@ CefRefPtr<CefXmlReader> CefXmlReader::Create(CefRefPtr<CefStreamReader> stream,
                                              EncodingType encodingType,
                                              const CefString& URI) {
   CefRefPtr<CefXmlReaderImpl> impl(new CefXmlReaderImpl());
-  if (!impl->Initialize(stream, encodingType, URI))
+  if (!impl->Initialize(stream, encodingType, URI)) {
     return nullptr;
+  }
   return impl.get();
 }
 
@@ -53,12 +54,14 @@ void XMLCALL xml_error_callback(void* arg,
                                 const char* msg,
                                 xmlParserSeverities severity,
                                 xmlTextReaderLocatorPtr locator) {
-  if (!msg)
+  if (!msg) {
     return;
+  }
 
   std::string error_str(msg);
-  if (!error_str.empty() && error_str[error_str.length() - 1] == '\n')
+  if (!error_str.empty() && error_str[error_str.length() - 1] == '\n') {
     error_str.resize(error_str.length() - 1);
+  }
 
   std::stringstream ss;
   ss << error_str << ", line " << xmlTextReaderLocatorLineNumber(locator);
@@ -78,12 +81,14 @@ void XMLCALL xml_error_callback(void* arg,
  * the module handles the new error reporting mechanism.
  */
 void XMLCALL xml_structured_error_callback(void* userData, xmlErrorPtr error) {
-  if (!error->message)
+  if (!error->message) {
     return;
+  }
 
   std::string error_str(error->message);
-  if (!error_str.empty() && error_str[error_str.length() - 1] == '\n')
+  if (!error_str.empty() && error_str[error_str.length() - 1] == '\n') {
     error_str.resize(error_str.length() - 1);
+  }
 
   std::stringstream ss;
   ss << error_str << ", line " << error->line;
@@ -95,14 +100,16 @@ void XMLCALL xml_structured_error_callback(void* userData, xmlErrorPtr error) {
 }
 
 CefString xmlCharToString(const xmlChar* xmlStr, bool free) {
-  if (!xmlStr)
+  if (!xmlStr) {
     return CefString();
+  }
 
   const char* str = reinterpret_cast<const char*>(xmlStr);
   CefString wstr = std::string(str);
 
-  if (free)
+  if (free) {
     xmlFree(const_cast<xmlChar*>(xmlStr));
+  }
 
   return wstr;
 }
@@ -148,8 +155,9 @@ bool CefXmlReaderImpl::Initialize(CefRefPtr<CefStreamReader> stream,
 
   // Create the input buffer.
   xmlParserInputBufferPtr input_buffer = xmlAllocParserInputBuffer(enc);
-  if (!input_buffer)
+  if (!input_buffer) {
     return false;
+  }
 
   input_buffer->context = stream.get();
   input_buffer->readcallback = xml_read_callback;
@@ -175,15 +183,17 @@ bool CefXmlReaderImpl::Initialize(CefRefPtr<CefStreamReader> stream,
 }
 
 bool CefXmlReaderImpl::MoveToNextNode() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   return xmlTextReaderRead(reader_) == 1 ? true : false;
 }
 
 bool CefXmlReaderImpl::Close() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   // The input buffer will be freed automatically.
   xmlFreeTextReader(reader_);
@@ -192,22 +202,25 @@ bool CefXmlReaderImpl::Close() {
 }
 
 bool CefXmlReaderImpl::HasError() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   return !error_buf_.str().empty();
 }
 
 CefString CefXmlReaderImpl::GetError() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return CefString();
+  }
 
   return error_buf_.str();
 }
 
 CefXmlReader::NodeType CefXmlReaderImpl::GetType() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return XML_NODE_UNSUPPORTED;
+  }
 
   switch (xmlTextReaderNodeType(reader_)) {
     case XML_READER_TYPE_ELEMENT:
@@ -239,64 +252,73 @@ CefXmlReader::NodeType CefXmlReaderImpl::GetType() {
 }
 
 int CefXmlReaderImpl::GetDepth() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return -1;
+  }
 
   return xmlTextReaderDepth(reader_);
 }
 
 CefString CefXmlReaderImpl::GetLocalName() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return CefString();
+  }
 
   return xmlCharToString(xmlTextReaderConstLocalName(reader_), false);
 }
 
 CefString CefXmlReaderImpl::GetPrefix() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return CefString();
+  }
 
   return xmlCharToString(xmlTextReaderConstPrefix(reader_), false);
 }
 
 CefString CefXmlReaderImpl::GetQualifiedName() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return CefString();
+  }
 
   return xmlCharToString(xmlTextReaderConstName(reader_), false);
 }
 
 CefString CefXmlReaderImpl::GetNamespaceURI() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return CefString();
+  }
 
   return xmlCharToString(xmlTextReaderConstNamespaceUri(reader_), false);
 }
 
 CefString CefXmlReaderImpl::GetBaseURI() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return CefString();
+  }
 
   return xmlCharToString(xmlTextReaderConstBaseUri(reader_), false);
 }
 
 CefString CefXmlReaderImpl::GetXmlLang() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return CefString();
+  }
 
   return xmlCharToString(xmlTextReaderConstXmlLang(reader_), false);
 }
 
 bool CefXmlReaderImpl::IsEmptyElement() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   return xmlTextReaderIsEmptyElement(reader_) == 1 ? true : false;
 }
 
 bool CefXmlReaderImpl::HasValue() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   if (xmlTextReaderNodeType(reader_) == XML_READER_TYPE_ENTITY_REFERENCE) {
     // Provide special handling to return entity reference values.
@@ -307,14 +329,16 @@ bool CefXmlReaderImpl::HasValue() {
 }
 
 CefString CefXmlReaderImpl::GetValue() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return CefString();
+  }
 
   if (xmlTextReaderNodeType(reader_) == XML_READER_TYPE_ENTITY_REFERENCE) {
     // Provide special handling to return entity reference values.
     xmlNodePtr node = xmlTextReaderCurrentNode(reader_);
-    if (node->content != nullptr)
+    if (node->content != nullptr) {
       return xmlCharToString(node->content, false);
+    }
     return CefString();
   } else {
     return xmlCharToString(xmlTextReaderConstValue(reader_), false);
@@ -322,29 +346,33 @@ CefString CefXmlReaderImpl::GetValue() {
 }
 
 bool CefXmlReaderImpl::HasAttributes() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   return xmlTextReaderHasAttributes(reader_) == 1 ? true : false;
 }
 
 size_t CefXmlReaderImpl::GetAttributeCount() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return 0;
+  }
 
   return xmlTextReaderAttributeCount(reader_);
 }
 
 CefString CefXmlReaderImpl::GetAttribute(int index) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return CefString();
+  }
 
   return xmlCharToString(xmlTextReaderGetAttributeNo(reader_, index), true);
 }
 
 CefString CefXmlReaderImpl::GetAttribute(const CefString& qualifiedName) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return CefString();
+  }
 
   std::string qualifiedNameStr = qualifiedName;
   return xmlCharToString(
@@ -354,8 +382,9 @@ CefString CefXmlReaderImpl::GetAttribute(const CefString& qualifiedName) {
 
 CefString CefXmlReaderImpl::GetAttribute(const CefString& localName,
                                          const CefString& namespaceURI) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return CefString();
+  }
 
   std::string localNameStr = localName;
   std::string namespaceURIStr = namespaceURI;
@@ -366,36 +395,41 @@ CefString CefXmlReaderImpl::GetAttribute(const CefString& localName,
 }
 
 CefString CefXmlReaderImpl::GetInnerXml() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return CefString();
+  }
 
   return xmlCharToString(xmlTextReaderReadInnerXml(reader_), true);
 }
 
 CefString CefXmlReaderImpl::GetOuterXml() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return CefString();
+  }
 
   return xmlCharToString(xmlTextReaderReadOuterXml(reader_), true);
 }
 
 int CefXmlReaderImpl::GetLineNumber() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return -1;
+  }
 
   return xmlTextReaderGetParserLineNumber(reader_);
 }
 
 bool CefXmlReaderImpl::MoveToAttribute(int index) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   return xmlTextReaderMoveToAttributeNo(reader_, index) == 1 ? true : false;
 }
 
 bool CefXmlReaderImpl::MoveToAttribute(const CefString& qualifiedName) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   std::string qualifiedNameStr = qualifiedName;
   return xmlTextReaderMoveToAttribute(reader_,
@@ -406,8 +440,9 @@ bool CefXmlReaderImpl::MoveToAttribute(const CefString& qualifiedName) {
 
 bool CefXmlReaderImpl::MoveToAttribute(const CefString& localName,
                                        const CefString& namespaceURI) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   std::string localNameStr = localName;
   std::string namespaceURIStr = namespaceURI;
@@ -418,29 +453,33 @@ bool CefXmlReaderImpl::MoveToAttribute(const CefString& localName,
 }
 
 bool CefXmlReaderImpl::MoveToFirstAttribute() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   return xmlTextReaderMoveToFirstAttribute(reader_) == 1 ? true : false;
 }
 
 bool CefXmlReaderImpl::MoveToNextAttribute() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   return xmlTextReaderMoveToNextAttribute(reader_) == 1 ? true : false;
 }
 
 bool CefXmlReaderImpl::MoveToCarryingElement() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   return xmlTextReaderMoveToElement(reader_) == 1 ? true : false;
 }
 
 void CefXmlReaderImpl::AppendError(const CefString& error_str) {
-  if (!error_buf_.str().empty())
+  if (!error_buf_.str().empty()) {
     error_buf_ << L"\n";
+  }
   error_buf_ << error_str.ToString();
 }
 
diff --git a/libcef/browser/zip_reader_impl.cc b/libcef/browser/zip_reader_impl.cc
index b194c604a..74643c6ce 100644
--- a/libcef/browser/zip_reader_impl.cc
+++ b/libcef/browser/zip_reader_impl.cc
@@ -15,8 +15,9 @@
 CefRefPtr<CefZipReader> CefZipReader::Create(
     CefRefPtr<CefStreamReader> stream) {
   CefRefPtr<CefZipReaderImpl> impl(new CefZipReaderImpl());
-  if (!impl->Initialize(stream))
+  if (!impl->Initialize(stream)) {
     return nullptr;
+  }
   return impl.get();
 }
 
@@ -89,8 +90,9 @@ CefZipReaderImpl::~CefZipReaderImpl() {
     if (!VerifyContext()) {
       // Close() is supposed to be called directly. We'll try to free the reader
       // now on the wrong thread but there's no guarantee this call won't crash.
-      if (has_fileopen_)
+      if (has_fileopen_) {
         unzCloseCurrentFile(reader_);
+      }
       unzClose(reader_);
     } else {
       Close();
@@ -117,11 +119,13 @@ bool CefZipReaderImpl::Initialize(CefRefPtr<CefStreamReader> stream) {
 }
 
 bool CefZipReaderImpl::MoveToFirstFile() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
-  if (has_fileopen_)
+  if (has_fileopen_) {
     CloseFile();
+  }
 
   has_fileinfo_ = false;
 
@@ -129,11 +133,13 @@ bool CefZipReaderImpl::MoveToFirstFile() {
 }
 
 bool CefZipReaderImpl::MoveToNextFile() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
-  if (has_fileopen_)
+  if (has_fileopen_) {
     CloseFile();
+  }
 
   has_fileinfo_ = false;
 
@@ -142,11 +148,13 @@ bool CefZipReaderImpl::MoveToNextFile() {
 
 bool CefZipReaderImpl::MoveToFile(const CefString& fileName,
                                   bool caseSensitive) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
-  if (has_fileopen_)
+  if (has_fileopen_) {
     CloseFile();
+  }
 
   has_fileinfo_ = false;
 
@@ -156,11 +164,13 @@ bool CefZipReaderImpl::MoveToFile(const CefString& fileName,
 }
 
 bool CefZipReaderImpl::Close() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
-  if (has_fileopen_)
+  if (has_fileopen_) {
     CloseFile();
+  }
 
   int result = unzClose(reader_);
   reader_ = nullptr;
@@ -168,32 +178,37 @@ bool CefZipReaderImpl::Close() {
 }
 
 CefString CefZipReaderImpl::GetFileName() {
-  if (!VerifyContext() || !GetFileInfo())
+  if (!VerifyContext() || !GetFileInfo()) {
     return CefString();
+  }
 
   return filename_;
 }
 
 int64 CefZipReaderImpl::GetFileSize() {
-  if (!VerifyContext() || !GetFileInfo())
+  if (!VerifyContext() || !GetFileInfo()) {
     return -1;
+  }
 
   return filesize_;
 }
 
 CefBaseTime CefZipReaderImpl::GetFileLastModified() {
-  if (!VerifyContext() || !GetFileInfo())
+  if (!VerifyContext() || !GetFileInfo()) {
     return CefBaseTime();
+  }
 
   return base::Time::FromTimeT(filemodified_);
 }
 
 bool CefZipReaderImpl::OpenFile(const CefString& password) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
-  if (has_fileopen_)
+  if (has_fileopen_) {
     CloseFile();
+  }
 
   bool ret;
 
@@ -204,14 +219,16 @@ bool CefZipReaderImpl::OpenFile(const CefString& password) {
     ret = (unzOpenCurrentFilePassword(reader_, passwordStr.c_str()) == UNZ_OK);
   }
 
-  if (ret)
+  if (ret) {
     has_fileopen_ = true;
+  }
   return ret;
 }
 
 bool CefZipReaderImpl::CloseFile() {
-  if (!VerifyContext() || !has_fileopen_)
+  if (!VerifyContext() || !has_fileopen_) {
     return false;
+  }
 
   has_fileopen_ = false;
   has_fileinfo_ = false;
@@ -220,29 +237,33 @@ bool CefZipReaderImpl::CloseFile() {
 }
 
 int CefZipReaderImpl::ReadFile(void* buffer, size_t bufferSize) {
-  if (!VerifyContext() || !has_fileopen_)
+  if (!VerifyContext() || !has_fileopen_) {
     return -1;
+  }
 
   return unzReadCurrentFile(reader_, buffer, bufferSize);
 }
 
 int64 CefZipReaderImpl::Tell() {
-  if (!VerifyContext() || !has_fileopen_)
+  if (!VerifyContext() || !has_fileopen_) {
     return -1;
+  }
 
   return unztell64(reader_);
 }
 
 bool CefZipReaderImpl::Eof() {
-  if (!VerifyContext() || !has_fileopen_)
+  if (!VerifyContext() || !has_fileopen_) {
     return true;
+  }
 
   return (unzeof(reader_) == 1 ? true : false);
 }
 
 bool CefZipReaderImpl::GetFileInfo() {
-  if (has_fileinfo_)
+  if (has_fileinfo_) {
     return true;
+  }
 
   char file_name[512] = {0};
   unz_file_info file_info;
diff --git a/libcef/common/alloy/alloy_content_client.cc b/libcef/common/alloy/alloy_content_client.cc
index 5d653ab40..dec9977f4 100644
--- a/libcef/common/alloy/alloy_content_client.cc
+++ b/libcef/common/alloy/alloy_content_client.cc
@@ -87,12 +87,14 @@ void AlloyContentClient::AddPlugins(
 void AlloyContentClient::AddContentDecryptionModules(
     std::vector<content::CdmInfo>* cdms,
     std::vector<media::CdmHostFilePath>* cdm_host_file_paths) {
-  if (cdms)
+  if (cdms) {
     RegisterCdmInfo(cdms);
+  }
 
 #if BUILDFLAG(ENABLE_CDM_HOST_VERIFICATION)
-  if (cdm_host_file_paths)
+  if (cdm_host_file_paths) {
     cef::AddCdmHostFilePaths(cdm_host_file_paths);
+  }
 #endif
 }
 
@@ -103,8 +105,9 @@ void AlloyContentClient::AddAdditionalSchemes(Schemes* schemes) {
 std::u16string AlloyContentClient::GetLocalizedString(int message_id) {
   std::u16string value =
       ui::ResourceBundle::GetSharedInstance().GetLocalizedString(message_id);
-  if (value.empty())
+  if (value.empty()) {
     LOG(ERROR) << "No localized string available for id " << message_id;
+  }
 
   return value;
 }
@@ -113,8 +116,9 @@ std::u16string AlloyContentClient::GetLocalizedString(
     int message_id,
     const std::u16string& replacement) {
   std::u16string value = l10n_util::GetStringFUTF16(message_id, replacement);
-  if (value.empty())
+  if (value.empty()) {
     LOG(ERROR) << "No localized string available for id " << message_id;
+  }
 
   return value;
 }
@@ -125,8 +129,9 @@ base::StringPiece AlloyContentClient::GetDataResource(
   base::StringPiece value =
       ui::ResourceBundle::GetSharedInstance().GetRawDataResourceForScale(
           resource_id, scale_factor);
-  if (value.empty())
+  if (value.empty()) {
     LOG(ERROR) << "No data resource available for id " << resource_id;
+  }
 
   return value;
 }
@@ -136,8 +141,9 @@ base::RefCountedMemory* AlloyContentClient::GetDataResourceBytes(
   base::RefCountedMemory* value =
       ui::ResourceBundle::GetSharedInstance().LoadDataResourceBytes(
           resource_id);
-  if (!value)
+  if (!value) {
     LOG(ERROR) << "No data resource bytes available for id " << resource_id;
+  }
 
   return value;
 }
@@ -145,8 +151,9 @@ base::RefCountedMemory* AlloyContentClient::GetDataResourceBytes(
 gfx::Image& AlloyContentClient::GetNativeImageNamed(int resource_id) {
   gfx::Image& value =
       ui::ResourceBundle::GetSharedInstance().GetNativeImageNamed(resource_id);
-  if (value.IsEmpty())
+  if (value.IsEmpty()) {
     LOG(ERROR) << "No native image available for id " << resource_id;
+  }
 
   return value;
 }
diff --git a/libcef/common/alloy/alloy_main_delegate.cc b/libcef/common/alloy/alloy_main_delegate.cc
index 7c6eb415e..d79c6a8c6 100644
--- a/libcef/common/alloy/alloy_main_delegate.cc
+++ b/libcef/common/alloy/alloy_main_delegate.cc
@@ -128,20 +128,23 @@ absl::optional<int> AlloyMainDelegate::BasicStartupComplete() {
     if (settings_->framework_dir_path.length > 0) {
       base::FilePath file_path =
           base::FilePath(CefString(&settings_->framework_dir_path));
-      if (!file_path.empty())
+      if (!file_path.empty()) {
         command_line->AppendSwitchPath(switches::kFrameworkDirPath, file_path);
+      }
     }
 
     if (settings_->main_bundle_path.length > 0) {
       base::FilePath file_path =
           base::FilePath(CefString(&settings_->main_bundle_path));
-      if (!file_path.empty())
+      if (!file_path.empty()) {
         command_line->AppendSwitchPath(switches::kMainBundlePath, file_path);
+      }
     }
 #endif
 
-    if (no_sandbox)
+    if (no_sandbox) {
       command_line->AppendSwitch(sandbox::policy::switches::kNoSandbox);
+    }
 
     if (settings_->user_agent.length > 0) {
       command_line->AppendSwitchASCII(
@@ -162,18 +165,22 @@ absl::optional<int> AlloyMainDelegate::BasicStartupComplete() {
 
     base::FilePath log_file;
     bool has_log_file_cmdline = false;
-    if (settings_->log_file.length > 0)
+    if (settings_->log_file.length > 0) {
       log_file = base::FilePath(CefString(&settings_->log_file));
+    }
     if (log_file.empty() && command_line->HasSwitch(switches::kLogFile)) {
       log_file = command_line->GetSwitchValuePath(switches::kLogFile);
-      if (!log_file.empty())
+      if (!log_file.empty()) {
         has_log_file_cmdline = true;
+      }
     }
-    if (log_file.empty())
+    if (log_file.empty()) {
       log_file = resource_util::GetDefaultLogFilePath();
+    }
     DCHECK(!log_file.empty());
-    if (!has_log_file_cmdline)
+    if (!has_log_file_cmdline) {
       command_line->AppendSwitchPath(switches::kLogFile, log_file);
+    }
 
     if (settings_->log_severity != LOGSEVERITY_DEFAULT) {
       std::string log_severity;
@@ -199,8 +206,9 @@ absl::optional<int> AlloyMainDelegate::BasicStartupComplete() {
         default:
           break;
       }
-      if (!log_severity.empty())
+      if (!log_severity.empty()) {
         command_line->AppendSwitchASCII(switches::kLogSeverity, log_severity);
+      }
     }
 
     if (settings_->javascript_flags.length > 0) {
@@ -224,8 +232,9 @@ absl::optional<int> AlloyMainDelegate::BasicStartupComplete() {
       if (settings_->locales_dir_path.length > 0) {
         base::FilePath file_path =
             base::FilePath(CefString(&settings_->locales_dir_path));
-        if (!file_path.empty())
+        if (!file_path.empty()) {
           command_line->AppendSwitchPath(switches::kLocalesDirPath, file_path);
+        }
       }
     }
 
@@ -272,8 +281,9 @@ absl::optional<int> AlloyMainDelegate::BasicStartupComplete() {
       std::string disable_features_str =
           command_line->GetSwitchValueASCII(switches::kDisableFeatures);
       for (auto feature_str : disable_features) {
-        if (!disable_features_str.empty())
+        if (!disable_features_str.empty()) {
           disable_features_str += ",";
+        }
         disable_features_str += feature_str;
       }
       command_line->AppendSwitchASCII(switches::kDisableFeatures,
@@ -368,8 +378,9 @@ void AlloyMainDelegate::PreSandboxStartup() {
 
   resource_util::OverrideUserDataDir(settings_, command_line);
 
-  if (command_line->HasSwitch(switches::kDisablePackLoading))
+  if (command_line->HasSwitch(switches::kDisablePackLoading)) {
     resource_bundle_delegate_.set_pack_loading_disabled(true);
+  }
 
   // Initialize crash reporting state for this process/module.
   // chrome::DIR_CRASH_DUMPS must be configured before calling this function.
@@ -425,8 +436,9 @@ content::ContentUtilityClient* AlloyMainDelegate::CreateContentUtilityClient() {
 }
 
 CefRefPtr<CefRequestContext> AlloyMainDelegate::GetGlobalRequestContext() {
-  if (!browser_client_)
+  if (!browser_client_) {
     return nullptr;
+  }
   return browser_client_->request_context();
 }
 
@@ -441,36 +453,41 @@ CefBrowserContext* AlloyMainDelegate::CreateNewBrowserContext(
 
 scoped_refptr<base::SingleThreadTaskRunner>
 AlloyMainDelegate::GetBackgroundTaskRunner() {
-  if (browser_client_)
+  if (browser_client_) {
     return browser_client_->background_task_runner();
+  }
   return nullptr;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 AlloyMainDelegate::GetUserVisibleTaskRunner() {
-  if (browser_client_)
+  if (browser_client_) {
     return browser_client_->user_visible_task_runner();
+  }
   return nullptr;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 AlloyMainDelegate::GetUserBlockingTaskRunner() {
-  if (browser_client_)
+  if (browser_client_) {
     return browser_client_->user_blocking_task_runner();
+  }
   return nullptr;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 AlloyMainDelegate::GetRenderTaskRunner() {
-  if (renderer_client_)
+  if (renderer_client_) {
     return renderer_client_->render_task_runner();
+  }
   return nullptr;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 AlloyMainDelegate::GetWebWorkerTaskRunner() {
-  if (renderer_client_)
+  if (renderer_client_) {
     return renderer_client_->GetCurrentTaskRunner();
+  }
   return nullptr;
 }
 
@@ -485,10 +502,12 @@ void AlloyMainDelegate::InitializeResourceBundle() {
     resources_dir =
         command_line->GetSwitchValuePath(switches::kResourcesDirPath);
   }
-  if (resources_dir.empty())
+  if (resources_dir.empty()) {
     resources_dir = resource_util::GetResourcesDir();
-  if (!resources_dir.empty())
+  }
+  if (!resources_dir.empty()) {
     base::PathService::Override(chrome::DIR_RESOURCES, resources_dir);
+  }
 
   if (!resource_bundle_delegate_.pack_loading_disabled()) {
     if (!resources_dir.empty()) {
@@ -501,11 +520,13 @@ void AlloyMainDelegate::InitializeResourceBundle() {
           resources_dir.Append(FILE_PATH_LITERAL("chrome_200_percent.pak"));
     }
 
-    if (command_line->HasSwitch(switches::kLocalesDirPath))
+    if (command_line->HasSwitch(switches::kLocalesDirPath)) {
       locales_dir = command_line->GetSwitchValuePath(switches::kLocalesDirPath);
+    }
 
-    if (!locales_dir.empty())
+    if (!locales_dir.empty()) {
       base::PathService::Override(ui::DIR_LOCALES, locales_dir);
+    }
   }
 
 #if BUILDFLAG(IS_WIN)
@@ -516,8 +537,9 @@ void AlloyMainDelegate::InitializeResourceBundle() {
   // https://crbug.com/1178117.
   auto module_handle =
       ::GetModuleHandle(CefAppManager::Get()->GetResourceDllName());
-  if (!module_handle)
+  if (!module_handle) {
     module_handle = ::GetModuleHandle(NULL);
+  }
 
   ui::SetResourcesDataDLL(module_handle);
 #endif
@@ -529,14 +551,16 @@ void AlloyMainDelegate::InitializeResourceBundle() {
       ui::ResourceBundle::InitSharedInstanceWithLocale(
           locale, &resource_bundle_delegate_,
           ui::ResourceBundle::LOAD_COMMON_RESOURCES);
-  if (!loaded_locale.empty() && g_browser_process)
+  if (!loaded_locale.empty() && g_browser_process) {
     g_browser_process->SetApplicationLocale(loaded_locale);
+  }
 
   ui::ResourceBundle& resource_bundle = ui::ResourceBundle::GetSharedInstance();
 
   if (!resource_bundle_delegate_.pack_loading_disabled()) {
-    if (loaded_locale.empty())
+    if (loaded_locale.empty()) {
       LOG(ERROR) << "Could not load locale pak for " << locale;
+    }
 
     resource_bundle_delegate_.set_allow_pack_file_load(true);
 
diff --git a/libcef/common/app_manager.cc b/libcef/common/app_manager.cc
index 4c1e3c00e..167393a7e 100644
--- a/libcef/common/app_manager.cc
+++ b/libcef/common/app_manager.cc
@@ -50,20 +50,23 @@ void CefAppManager::AddCustomScheme(CefSchemeInfo* scheme_info) {
     // resource_dispatcher_host_impl.cc ShouldServiceRequest.
     content::ChildProcessSecurityPolicy* policy =
         content::ChildProcessSecurityPolicy::GetInstance();
-    if (!policy->IsWebSafeScheme(scheme_info->scheme_name))
+    if (!policy->IsWebSafeScheme(scheme_info->scheme_name)) {
       policy->RegisterWebSafeScheme(scheme_info->scheme_name);
+    }
   }
 }
 
 bool CefAppManager::HasCustomScheme(const std::string& scheme_name) {
   DCHECK(scheme_info_list_locked_);
-  if (scheme_info_list_.empty())
+  if (scheme_info_list_.empty()) {
     return false;
+  }
 
   SchemeInfoList::const_iterator it = scheme_info_list_.begin();
   for (; it != scheme_info_list_.end(); ++it) {
-    if (it->scheme_name == scheme_name)
+    if (it->scheme_name == scheme_name) {
       return true;
+    }
   }
 
   return false;
diff --git a/libcef/common/base_impl.cc b/libcef/common/base_impl.cc
index 3ec629616..1a56c1077 100644
--- a/libcef/common/base_impl.cc
+++ b/libcef/common/base_impl.cc
@@ -26,8 +26,9 @@ CEF_EXPORT void cef_trace_event_instant(const char* /* category */,
                                         uint64 arg2_val,
                                         int copy) {
   DCHECK(name);
-  if (!name)
+  if (!name) {
     return;
+  }
 
   if (copy) {
     if (arg1_name == nullptr && arg2_name == nullptr) {
@@ -60,8 +61,9 @@ CEF_EXPORT void cef_trace_event_begin(const char* /* category */,
                                       uint64 arg2_val,
                                       int copy) {
   DCHECK(name);
-  if (!name)
+  if (!name) {
     return;
+  }
 
   if (copy) {
     if (arg1_name == nullptr && arg2_name == nullptr) {
@@ -93,8 +95,9 @@ CEF_EXPORT void cef_trace_event_end(const char* /* category */,
                                     uint64 arg2_val,
                                     int copy) {
   DCHECK(name);
-  if (!name)
+  if (!name) {
     return;
+  }
 
   if (copy) {
     if (arg1_name == nullptr && arg2_name == nullptr) {
@@ -126,8 +129,9 @@ CEF_EXPORT void cef_trace_counter(const char* /* category */,
                                   uint64 value2_val,
                                   int copy) {
   DCHECK(name);
-  if (!name)
+  if (!name) {
     return;
+  }
 
   if (copy) {
     if (value1_name == nullptr && value2_name == nullptr) {
@@ -155,8 +159,9 @@ CEF_EXPORT void cef_trace_counter_id(const char* /* category */,
                                      uint64 value2_val,
                                      int copy) {
   DCHECK(name);
-  if (!name)
+  if (!name) {
     return;
+  }
 
   if (copy) {
     if (value1_name == nullptr && value2_name == nullptr) {
@@ -184,8 +189,9 @@ CEF_EXPORT void cef_trace_event_async_begin(const char* /* category */,
                                             uint64 arg2_val,
                                             int copy) {
   DCHECK(name);
-  if (!name)
+  if (!name) {
     return;
+  }
 
   if (copy) {
     if (arg1_name == nullptr && arg2_name == nullptr) {
@@ -216,8 +222,9 @@ CEF_EXPORT void cef_trace_event_async_step_into(const char* /* category */,
                                                 uint64 arg1_val,
                                                 int copy) {
   DCHECK(name);
-  if (!name)
+  if (!name) {
     return;
+  }
 
   if (copy) {
     if (arg1_name == nullptr) {
@@ -247,8 +254,9 @@ CEF_EXPORT void cef_trace_event_async_step_past(const char* /* category */,
                                                 uint64 arg1_val,
                                                 int copy) {
   DCHECK(name);
-  if (!name)
+  if (!name) {
     return;
+  }
 
   if (copy) {
     if (arg1_name == nullptr) {
@@ -279,8 +287,9 @@ CEF_EXPORT void cef_trace_event_async_end(const char* /* category */,
                                           uint64 arg2_val,
                                           int copy) {
   DCHECK(name);
-  if (!name)
+  if (!name) {
     return;
+  }
 
   if (copy) {
     if (arg1_name == nullptr && arg2_name == nullptr) {
diff --git a/libcef/common/cef_crash_report_upload_thread.cc b/libcef/common/cef_crash_report_upload_thread.cc
index 2d98ef674..086771621 100644
--- a/libcef/common/cef_crash_report_upload_thread.cc
+++ b/libcef/common/cef_crash_report_upload_thread.cc
@@ -45,8 +45,9 @@ void CefCrashReportUploadThread::ProcessPendingReports() {
     // Count how many reports have completed in the last 24 hours.
     recent_upload_ct_ = 0;
     for (const CrashReportDatabase::Report& report : reports) {
-      if (report.last_upload_attempt_time > now - kSeconds)
+      if (report.last_upload_attempt_time > now - kSeconds) {
         recent_upload_ct_++;
+      }
     }
   }
 
@@ -59,8 +60,8 @@ void CefCrashReportUploadThread::ProcessPendingReport(
   // Always allow upload if it's been explicitly requested by the user.
   if (!report.upload_explicitly_requested) {
     if (!UploadsEnabled()) {
-      // Don’t attempt an upload if there’s no URL or if uploads have been
-      // disabled in the database’s settings.
+      // Don't attempt an upload if there's no URL or if uploads have been
+      // disabled in the database's settings.
       database_->SkipReportUpload(
           report.uuid, Metrics::CrashSkippedReason::kUploadsDisabled);
       return;
@@ -92,7 +93,7 @@ void CefCrashReportUploadThread::ProcessPendingReport(
     case CrashReportDatabase::kReportNotFound:
     case CrashReportDatabase::kFileSystemError:
     case CrashReportDatabase::kDatabaseError:
-      // In these cases, SkipReportUpload() might not work either, but it’s best
+      // In these cases, SkipReportUpload() might not work either, but it's best
       // to at least try to get the report out of the way.
       database_->SkipReportUpload(report.uuid,
                                   Metrics::CrashSkippedReason::kDatabaseError);
@@ -110,8 +111,9 @@ void CefCrashReportUploadThread::ProcessPendingReport(
     case UploadResult::kSuccess:
       // The upload completed successfully.
       database_->RecordUploadComplete(std::move(upload_report), response_body);
-      if (MaxUploadsEnabled())
+      if (MaxUploadsEnabled()) {
         recent_upload_ct_++;
+      }
       ResetBackoff();
       break;
     case UploadResult::kPermanentFailure:
@@ -148,8 +150,9 @@ bool CefCrashReportUploadThread::MaxUploadsExceeded() const {
 }
 
 bool CefCrashReportUploadThread::BackoffPending() const {
-  if (!options_.rate_limit)
+  if (!options_.rate_limit) {
     return false;
+  }
 
   Settings* const settings = database_->GetSettings();
 
@@ -157,16 +160,18 @@ bool CefCrashReportUploadThread::BackoffPending() const {
   if (settings->GetNextUploadAttemptTime(&next_upload_time) &&
       next_upload_time > 0) {
     const time_t now = time(nullptr);
-    if (now < next_upload_time)
+    if (now < next_upload_time) {
       return true;
+    }
   }
 
   return false;
 }
 
 void CefCrashReportUploadThread::IncreaseBackoff() {
-  if (!options_.rate_limit)
+  if (!options_.rate_limit) {
     return;
+  }
 
   const int kHour = 60 * 60;  // 1 hour
   const int kBackoffSchedule[] = {
@@ -183,10 +188,12 @@ void CefCrashReportUploadThread::IncreaseBackoff() {
   Settings* settings = database_->GetSettings();
 
   int backoff_step = 0;
-  if (settings->GetBackoffStep(&backoff_step) && backoff_step < 0)
+  if (settings->GetBackoffStep(&backoff_step) && backoff_step < 0) {
     backoff_step = 0;
-  if (++backoff_step > kBackoffScheduleSize)
+  }
+  if (++backoff_step > kBackoffScheduleSize) {
     backoff_step = kBackoffScheduleSize;
+  }
 
   time_t next_upload_time = time(nullptr);  // now
   next_upload_time += kBackoffSchedule[backoff_step - 1];
@@ -203,8 +210,9 @@ void CefCrashReportUploadThread::IncreaseBackoff() {
 }
 
 void CefCrashReportUploadThread::ResetBackoff() {
-  if (!options_.rate_limit)
+  if (!options_.rate_limit) {
     return;
+  }
 
   Settings* settings = database_->GetSettings();
   settings->SetBackoffStep(0);
diff --git a/libcef/common/cef_crash_report_utils.cc b/libcef/common/cef_crash_report_utils.cc
index 7242d7b25..2980643d6 100644
--- a/libcef/common/cef_crash_report_utils.cc
+++ b/libcef/common/cef_crash_report_utils.cc
@@ -17,8 +17,9 @@ ParameterMap FilterParameters(const ParameterMap& parameters) {
   for (size_t i = 0; true; ++i) {
     const std::string& key = "K-" + std::string(1, 'A' + i);
     ParameterMap::iterator it = in_map.find(key);
-    if (it == in_map.end())
+    if (it == in_map.end()) {
       break;
+    }
     key_map += it->second;
     in_map.erase(it);
   }
diff --git a/libcef/common/chrome/chrome_content_client_cef.cc b/libcef/common/chrome/chrome_content_client_cef.cc
index 55c68e19a..e64a6c3e4 100644
--- a/libcef/common/chrome/chrome_content_client_cef.cc
+++ b/libcef/common/chrome/chrome_content_client_cef.cc
@@ -19,12 +19,14 @@ ChromeContentClientCef::~ChromeContentClientCef() = default;
 void ChromeContentClientCef::AddContentDecryptionModules(
     std::vector<content::CdmInfo>* cdms,
     std::vector<media::CdmHostFilePath>* cdm_host_file_paths) {
-  if (cdms)
+  if (cdms) {
     RegisterCdmInfo(cdms);
+  }
 
 #if BUILDFLAG(ENABLE_CDM_HOST_VERIFICATION)
-  if (cdm_host_file_paths)
+  if (cdm_host_file_paths) {
     cef::AddCdmHostFilePaths(cdm_host_file_paths);
+  }
 #endif
 }
 
diff --git a/libcef/common/chrome/chrome_main_delegate_cef.cc b/libcef/common/chrome/chrome_main_delegate_cef.cc
index ec93d0de6..dd6d9483d 100644
--- a/libcef/common/chrome/chrome_main_delegate_cef.cc
+++ b/libcef/common/chrome/chrome_main_delegate_cef.cc
@@ -60,8 +60,9 @@ ChromeMainDelegateCef::~ChromeMainDelegateCef() = default;
 absl::optional<int> ChromeMainDelegateCef::BasicStartupComplete() {
   // Returns false if startup should proceed.
   auto result = ChromeMainDelegate::BasicStartupComplete();
-  if (result.has_value())
+  if (result.has_value()) {
     return result;
+  }
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 
@@ -142,8 +143,9 @@ absl::optional<int> ChromeMainDelegateCef::BasicStartupComplete() {
       std::string disable_features_str =
           command_line->GetSwitchValueASCII(switches::kDisableFeatures);
       for (auto feature_str : disable_features) {
-        if (!disable_features_str.empty())
+        if (!disable_features_str.empty()) {
           disable_features_str += ",";
+        }
         disable_features_str += feature_str;
       }
       command_line->AppendSwitchASCII(switches::kDisableFeatures,
@@ -247,8 +249,9 @@ ChromeMainDelegateCef::CreateContentRendererClient() {
 
 CefRefPtr<CefRequestContext> ChromeMainDelegateCef::GetGlobalRequestContext() {
   auto browser_client = content_browser_client();
-  if (browser_client)
+  if (browser_client) {
     return browser_client->request_context();
+  }
   return nullptr;
 }
 
@@ -263,40 +266,45 @@ CefBrowserContext* ChromeMainDelegateCef::CreateNewBrowserContext(
 scoped_refptr<base::SingleThreadTaskRunner>
 ChromeMainDelegateCef::GetBackgroundTaskRunner() {
   auto browser_client = content_browser_client();
-  if (browser_client)
+  if (browser_client) {
     return browser_client->background_task_runner();
+  }
   return nullptr;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 ChromeMainDelegateCef::GetUserVisibleTaskRunner() {
   auto browser_client = content_browser_client();
-  if (browser_client)
+  if (browser_client) {
     return browser_client->user_visible_task_runner();
+  }
   return nullptr;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 ChromeMainDelegateCef::GetUserBlockingTaskRunner() {
   auto browser_client = content_browser_client();
-  if (browser_client)
+  if (browser_client) {
     return browser_client->user_blocking_task_runner();
+  }
   return nullptr;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 ChromeMainDelegateCef::GetRenderTaskRunner() {
   auto renderer_client = content_renderer_client();
-  if (renderer_client)
+  if (renderer_client) {
     return renderer_client->render_task_runner();
+  }
   return nullptr;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 ChromeMainDelegateCef::GetWebWorkerTaskRunner() {
   auto renderer_client = content_renderer_client();
-  if (renderer_client)
+  if (renderer_client) {
     return renderer_client->GetCurrentTaskRunner();
+  }
   return nullptr;
 }
 
@@ -308,7 +316,8 @@ ChromeContentBrowserClientCef* ChromeMainDelegateCef::content_browser_client()
 
 ChromeContentRendererClientCef* ChromeMainDelegateCef::content_renderer_client()
     const {
-  if (!g_chrome_content_renderer_client.IsCreated())
+  if (!g_chrome_content_renderer_client.IsCreated()) {
     return nullptr;
+  }
   return g_chrome_content_renderer_client.Pointer();
 }
\ No newline at end of file
diff --git a/libcef/common/command_line_impl.cc b/libcef/common/command_line_impl.cc
index a4896dd0c..6c7db788a 100644
--- a/libcef/common/command_line_impl.cc
+++ b/libcef/common/command_line_impl.cc
@@ -65,8 +65,9 @@ void CefCommandLineImpl::GetArgv(std::vector<CefString>& argv) {
   CEF_VALUE_VERIFY_RETURN_VOID(false);
   const base::CommandLine::StringVector& cmd_argv = const_value().argv();
   base::CommandLine::StringVector::const_iterator it = cmd_argv.begin();
-  for (; it != cmd_argv.end(); ++it)
+  for (; it != cmd_argv.end(); ++it) {
     argv.push_back(*it);
+  }
 }
 
 CefString CefCommandLineImpl::GetCommandLineString() {
@@ -104,8 +105,9 @@ void CefCommandLineImpl::GetSwitches(SwitchMap& switches) {
   CEF_VALUE_VERIFY_RETURN_VOID(false);
   const base::CommandLine::SwitchMap& map = const_value().GetSwitches();
   base::CommandLine::SwitchMap::const_iterator it = map.begin();
-  for (; it != map.end(); ++it)
+  for (; it != map.end(); ++it) {
     switches.insert(std::make_pair(it->first, it->second));
+  }
 }
 
 void CefCommandLineImpl::AppendSwitch(const CefString& name) {
@@ -132,8 +134,9 @@ void CefCommandLineImpl::GetArguments(ArgumentList& arguments) {
   CEF_VALUE_VERIFY_RETURN_VOID(false);
   const base::CommandLine::StringVector& vec = const_value().GetArgs();
   base::CommandLine::StringVector::const_iterator it = vec.begin();
-  for (; it != vec.end(); ++it)
+  for (; it != vec.end(); ++it) {
     arguments.push_back(*it);
+  }
 }
 
 void CefCommandLineImpl::AppendArgument(const CefString& argument) {
@@ -168,8 +171,9 @@ CefRefPtr<CefCommandLine> CefCommandLine::GetGlobalCommandLine() {
   static CefRefPtr<CefCommandLineImpl> commandLinePtr;
   if (!commandLinePtr.get()) {
     base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
-    if (command_line)
+    if (command_line) {
       commandLinePtr = new CefCommandLineImpl(command_line, false, true);
+    }
   }
   return commandLinePtr.get();
 }
diff --git a/libcef/common/crash_reporter_client.cc b/libcef/common/crash_reporter_client.cc
index 89b293b14..da8712804 100644
--- a/libcef/common/crash_reporter_client.cc
+++ b/libcef/common/crash_reporter_client.cc
@@ -62,16 +62,18 @@ PathString GetCrashConfigPath() {
 #if BUILDFLAG(IS_WIN)
   // Start with the path to the running executable.
   wchar_t module_path[MAX_PATH];
-  if (GetModuleFileName(nullptr, module_path, MAX_PATH) == 0)
+  if (GetModuleFileName(nullptr, module_path, MAX_PATH) == 0) {
     return PathString();
+  }
 
   PathString config_path = module_path;
 
   // Remove the executable file name.
   PathString::size_type last_backslash =
       config_path.rfind(kPathSep, config_path.size());
-  if (last_backslash != PathString::npos)
+  if (last_backslash != PathString::npos) {
     config_path.erase(last_backslash + 1);
+  }
 
   config_path += L"crash_reporter.cfg";
   return config_path;
@@ -86,8 +88,9 @@ PathString GetCrashConfigPath() {
 
   if (config_path.empty()) {
     // Start with the path to the running executable.
-    if (!base::PathService::Get(base::DIR_EXE, &config_path))
+    if (!base::PathService::Get(base::DIR_EXE, &config_path)) {
       return PathString();
+    }
   }
 
   return config_path.Append(FILE_PATH_LITERAL("crash_reporter.cfg")).value();
@@ -106,11 +109,13 @@ const unsigned maxFilenameLength = 255;
 const char kInvalidFileChars[] = "<>:\"/\\|?*";
 
 bool isInvalidFileCharacter(unsigned char c) {
-  if (c < ' ' || c == 0x7F)
+  if (c < ' ' || c == 0x7F) {
     return true;
+  }
   for (size_t i = 0; i < sizeof(kInvalidFileChars); ++i) {
-    if (c == kInvalidFileChars[i])
+    if (c == kInvalidFileChars[i]) {
       return true;
+    }
   }
   return false;
 }
@@ -124,8 +129,9 @@ bool isAbsolutePath(const std::string& s) {
 }
 
 std::string extractAbsolutePathStart(std::string& s) {
-  if (!isAbsolutePath(s))
+  if (!isAbsolutePath(s)) {
     return std::string();
+  }
 
   std::string start;
   if (s[0] == kPathSep) {
@@ -141,14 +147,16 @@ std::string extractAbsolutePathStart(std::string& s) {
 }
 
 std::string sanitizePathComponentPart(const std::string& s) {
-  if (s.empty())
+  if (s.empty()) {
     return std::string();
+  }
 
   std::string result;
   result.reserve(s.length());
   for (size_t i = 0; i < s.length(); ++i) {
-    if (!isInvalidFileCharacter(s[i]))
+    if (!isInvalidFileCharacter(s[i])) {
       result.push_back(s[i]);
+    }
   }
   return result;
 }
@@ -170,13 +178,15 @@ std::string sanitizePathComponent(const std::string& s) {
   ext = sanitizePathComponentPart(ext);
 
   // Remove a ridiculously-long extension.
-  if (ext.length() >= maxFilenameLength)
+  if (ext.length() >= maxFilenameLength) {
     ext = std::string();
+  }
 
   // Truncate an overly-long filename, reserving one character for a dot.
   std::string::size_type max_name_len = maxFilenameLength - ext.length() - 1;
-  if (name.length() > max_name_len)
+  if (name.length() > max_name_len) {
     name = name.substr(0, max_name_len);
+  }
 
   return ext.empty() ? name : name + "." + ext;
 }
@@ -193,10 +203,12 @@ std::string sanitizePath(const std::string& s) {
                         base::SPLIT_WANT_NONEMPTY);
   for (size_t i = 0; i < parts.size(); ++i) {
     std::string part = parts[i];
-    if (part != "." && part != "..")
+    if (part != "." && part != "..") {
       part = sanitizePathComponent(part);
-    if (!result.empty() && result[result.length() - 1] != kPathSep)
+    }
+    if (!result.empty() && result[result.length() - 1] != kPathSep) {
       result += kPathSep;
+    }
     result += part;
   }
 
@@ -204,25 +216,31 @@ std::string sanitizePath(const std::string& s) {
 }
 
 std::string joinPath(const std::string& s1, const std::string& s2) {
-  if (s1.empty() && s2.empty())
+  if (s1.empty() && s2.empty()) {
     return std::string();
-  if (s1.empty())
+  }
+  if (s1.empty()) {
     return s2;
-  if (s2.empty())
+  }
+  if (s2.empty()) {
     return s1;
+  }
 
   // Don't try to join absolute paths on Windows.
   // Skip this check on POSIX where it's more difficult to differentiate.
-  if (isAbsolutePath(s2))
+  if (isAbsolutePath(s2)) {
     return s2;
+  }
 
   std::string result = s1;
-  if (result[result.size() - 1] != kPathSep)
+  if (result[result.size() - 1] != kPathSep) {
     result += kPathSep;
-  if (s2[0] == kPathSep)
+  }
+  if (s2[0] == kPathSep) {
     result += s2.substr(1);
-  else
+  } else {
     result += s2;
+  }
   return result;
 }
 
@@ -260,8 +278,9 @@ bool ParseBool(const std::string& value) {
 
 int ParseZeroBasedInt(const std::string& value) {
   int int_val;
-  if (base::StringToInt(value, &int_val) && int_val > 0)
+  if (base::StringToInt(value, &int_val) && int_val > 0) {
     return int_val;
+  }
   return 0;
 }
 
@@ -309,18 +328,21 @@ bool GetDefaultUserDataDirectory(std::wstring* result,
   if (user_data_dir.empty()) {
     // LOCALAPPDATA was not set; fallback to the temporary files path.
     DWORD size = ::GetTempPath(0, nullptr);
-    if (!size)
+    if (!size) {
       return false;
+    }
     user_data_dir.resize(size + 1);
     size = ::GetTempPath(size + 1, &user_data_dir[0]);
-    if (!size || size >= user_data_dir.size())
+    if (!size || size >= user_data_dir.size()) {
       return false;
+    }
     user_data_dir.resize(size);
   }
 
   result->swap(user_data_dir);
-  if ((*result)[result->length() - 1] != L'\\')
+  if ((*result)[result->length() - 1] != L'\\') {
     result->push_back(L'\\');
+  }
   result->append(install_sub_directory);
   result->push_back(L'\\');
   result->append(kUserDataDirname);
@@ -334,13 +356,15 @@ bool GetDefaultCrashDumpLocation(std::wstring* crash_dir,
   // In order to be able to start crash handling very early, we do not rely on
   // chrome's PathService entries (for DIR_CRASH_DUMPS) being available on
   // Windows. See https://crbug.com/564398.
-  if (!GetDefaultUserDataDirectory(crash_dir, install_sub_directory))
+  if (!GetDefaultUserDataDirectory(crash_dir, install_sub_directory)) {
     return false;
+  }
 
   // We have to make sure the user data dir exists on first run. See
   // http://crbug.com/591504.
-  if (!install_static::RecursiveDirectoryCreate(*crash_dir))
+  if (!install_static::RecursiveDirectoryCreate(*crash_dir)) {
     return false;
+  }
   crash_dir->append(L"\\Crashpad");
   return true;
 }
@@ -352,20 +376,23 @@ CefCrashReporterClient::~CefCrashReporterClient() {}
 
 // Be aware that logging is not initialized at the time this method is called.
 bool CefCrashReporterClient::ReadCrashConfigFile() {
-  if (has_crash_config_file_)
+  if (has_crash_config_file_) {
     return true;
+  }
 
   PathString config_path = GetCrashConfigPath();
-  if (config_path.empty())
+  if (config_path.empty()) {
     return false;
+  }
 
 #if BUILDFLAG(IS_WIN)
   FILE* fp = _wfopen(config_path.c_str(), L"r");
 #else
   FILE* fp = fopen(config_path.c_str(), "r");
 #endif
-  if (!fp)
+  if (!fp) {
     return false;
+  }
 
   char line[1000];
 
@@ -383,8 +410,9 @@ bool CefCrashReporterClient::ReadCrashConfigFile() {
   while (fgets(line, sizeof(line) - 1, fp) != nullptr) {
     std::string str = line;
     base::TrimString(str, base::kWhitespaceASCII, &str);
-    if (str.empty() || str[0] == '#')
+    if (str.empty() || str[0] == '#') {
       continue;
+    }
 
     if (str == "[Config]") {
       current_section = kConfigSection;
@@ -397,19 +425,22 @@ bool CefCrashReporterClient::ReadCrashConfigFile() {
       continue;
     }
 
-    if (current_section == kNoSection)
+    if (current_section == kNoSection) {
       continue;
+    }
 
     size_t div = str.find('=');
-    if (div == std::string::npos)
+    if (div == std::string::npos) {
       continue;
+    }
 
     std::string name_str = str.substr(0, div);
     base::TrimString(name_str, base::kWhitespaceASCII, &name_str);
     std::string val_str = str.substr(div + 1);
     base::TrimString(val_str, base::kWhitespaceASCII, &val_str);
-    if (name_str.empty())
+    if (name_str.empty()) {
       continue;
+    }
 
     if (current_section == kConfigSection) {
       if (name_str == "ServerURL") {
@@ -429,13 +460,15 @@ bool CefCrashReporterClient::ReadCrashConfigFile() {
       }
 #if BUILDFLAG(IS_WIN)
       else if (name_str == "ExternalHandler") {
-        if (!val_str.empty())
+        if (!val_str.empty()) {
           external_handler_ = sanitizePath(val_str);
+        }
       } else if (name_str == "AppName") {
         if (!val_str.empty()) {
           val_str = sanitizePathComponent(val_str);
-          if (!val_str.empty())
+          if (!val_str.empty()) {
             app_name_ = val_str;
+          }
         }
       }
 #elif BUILDFLAG(IS_MAC)
@@ -507,8 +540,9 @@ bool CefCrashReporterClient::ReadCrashConfigFile() {
                                crashpad::Annotation::kValueMaxSize);
       ids[i].Set(base::StringPiece(map_keys.data() + offset, length));
       offset += length;
-      if (offset >= map_keys.size())
+      if (offset >= map_keys.size()) {
         break;
+      }
     }
   }
 
@@ -537,14 +571,16 @@ bool CefCrashReporterClient::HasCrashConfigFile() const {
 
 // static
 void CefCrashReporterClient::InitializeCrashReportingForProcess() {
-  if (g_crash_reporter_client)
+  if (g_crash_reporter_client) {
     return;
+  }
 
   g_crash_reporter_client = new CefCrashReporterClient();
   ANNOTATE_LEAKING_OBJECT_PTR(g_crash_reporter_client);
 
-  if (!g_crash_reporter_client->ReadCrashConfigFile())
+  if (!g_crash_reporter_client->ReadCrashConfigFile()) {
     return;
+  }
 
   std::wstring process_type = install_static::GetSwitchValueFromCommandLine(
       ::GetCommandLineW(), install_static::kProcessType);
@@ -589,8 +625,9 @@ void CefCrashReporterClient::GetProductNameAndVersion(
 bool CefCrashReporterClient::GetCrashDumpLocation(std::wstring* crash_dir) {
   // By setting the BREAKPAD_DUMP_LOCATION environment variable, an alternate
   // location to write breakpad crash dumps can be set.
-  if (GetAlternativeCrashDumpLocation(crash_dir))
+  if (GetAlternativeCrashDumpLocation(crash_dir)) {
     return true;
+  }
 
   return GetDefaultCrashDumpLocation(crash_dir, base::UTF8ToWide(app_name_));
 }
@@ -652,8 +689,9 @@ std::string CefCrashReporterClient::GetUploadUrl() {
 // for supported arguments.
 void CefCrashReporterClient::GetCrashOptionalArguments(
     std::vector<std::string>* arguments) {
-  if (!rate_limit_)
+  if (!rate_limit_) {
     arguments->push_back(std::string("--no-rate-limit"));
+  }
 
   if (max_uploads_ > 0) {
     arguments->push_back(std::string("--max-uploads=") +
@@ -675,10 +713,12 @@ void CefCrashReporterClient::GetCrashOptionalArguments(
 
 std::wstring CefCrashReporterClient::GetCrashExternalHandler(
     const std::wstring& exe_dir) {
-  if (external_handler_.empty())
+  if (external_handler_.empty()) {
     return CrashReporterClient::GetCrashExternalHandler(exe_dir);
-  if (isAbsolutePath(external_handler_))
+  }
+  if (isAbsolutePath(external_handler_)) {
     return base::UTF8ToWide(external_handler_);
+  }
   return base::UTF8ToWide(
       joinPath(base::WideToUTF8(exe_dir), external_handler_));
 }
@@ -738,12 +778,14 @@ IDKEY_FUNCTION(L, 1024)
 
 bool CefCrashReporterClient::SetCrashKeyValue(const base::StringPiece& key,
                                               const base::StringPiece& value) {
-  if (key.empty() || crash_keys_.empty())
+  if (key.empty() || crash_keys_.empty()) {
     return false;
+  }
 
   KeyMap::const_iterator it = crash_keys_.find(NormalizeCrashKey(key));
-  if (it == crash_keys_.end())
+  if (it == crash_keys_.end()) {
     return false;
+  }
 
   const KeySize size = it->second.first;
   const size_t index = it->second.second;
diff --git a/libcef/common/crash_reporting.cc b/libcef/common/crash_reporting.cc
index 877852d52..61310ef54 100644
--- a/libcef/common/crash_reporting.cc
+++ b/libcef/common/crash_reporting.cc
@@ -90,8 +90,9 @@ base::LazyInstance<CefCrashReporterClient>::Leaky g_crash_reporter_client =
 void InitCrashReporter(const base::CommandLine& command_line,
                        const std::string& process_type) {
   CefCrashReporterClient* crash_client = g_crash_reporter_client.Pointer();
-  if (!crash_client->HasCrashConfigFile())
+  if (!crash_client->HasCrashConfigFile()) {
     return;
+  }
 
   crash_reporter::SetCrashReporterClient(crash_client);
 
@@ -139,8 +140,9 @@ void InitCrashReporter(const base::CommandLine& command_line,
 
 // Used to exclude command-line flags from crash reporting.
 bool IsBoringCEFSwitch(const std::string& flag) {
-  if (crash_keys::IsBoringChromeSwitch(flag))
+  if (crash_keys::IsBoringChromeSwitch(flag)) {
     return true;
+  }
 
   static const char* const kIgnoreSwitches[] = {
       // CEF internals.
@@ -154,14 +156,16 @@ bool IsBoringCEFSwitch(const std::string& flag) {
       "service-request-channel-token",
   };
 
-  if (!base::StartsWith(flag, "--", base::CompareCase::SENSITIVE))
+  if (!base::StartsWith(flag, "--", base::CompareCase::SENSITIVE)) {
     return false;
+  }
 
   size_t end = flag.find("=");
   size_t len = (end == std::string::npos) ? flag.length() - 2 : end - 2;
   for (size_t i = 0; i < std::size(kIgnoreSwitches); ++i) {
-    if (flag.compare(2, len, kIgnoreSwitches[i]) == 0)
+    if (flag.compare(2, len, kIgnoreSwitches[i]) == 0) {
       return true;
+    }
   }
   return false;
 }
@@ -174,8 +178,9 @@ bool Enabled() {
 
 bool SetCrashKeyValue(const base::StringPiece& key,
                       const base::StringPiece& value) {
-  if (!g_crash_reporting_enabled)
+  if (!g_crash_reporting_enabled) {
     return false;
+  }
 
 #if BUILDFLAG(IS_WIN)
   return SetCrashKeyValueTrampoline(key, value);
diff --git a/libcef/common/drag_data_impl.cc b/libcef/common/drag_data_impl.cc
index a645ed526..49ea0e1d7 100644
--- a/libcef/common/drag_data_impl.cc
+++ b/libcef/common/drag_data_impl.cc
@@ -102,28 +102,32 @@ CefString CefDragDataImpl::GetFileName() {
 
 size_t CefDragDataImpl::GetFileContents(CefRefPtr<CefStreamWriter> writer) {
   base::AutoLock lock_scope(lock_);
-  if (data_.file_contents.empty())
+  if (data_.file_contents.empty()) {
     return 0;
+  }
 
   char* data = const_cast<char*>(data_.file_contents.c_str());
   size_t size = data_.file_contents.size();
 
-  if (!writer.get())
+  if (!writer.get()) {
     return size;
+  }
 
   return writer->Write(data, 1, size);
 }
 
 bool CefDragDataImpl::GetFileNames(std::vector<CefString>& names) {
   base::AutoLock lock_scope(lock_);
-  if (data_.filenames.empty())
+  if (data_.filenames.empty()) {
     return false;
+  }
 
   std::vector<ui::FileInfo>::const_iterator it = data_.filenames.begin();
   for (; it != data_.filenames.end(); ++it) {
     auto name = it->display_name.value();
-    if (name.empty())
+    if (name.empty()) {
       name = it->path.value();
+    }
     names.push_back(name);
   }
 
@@ -190,8 +194,9 @@ void CefDragDataImpl::ClearFilenames() {
 
 void CefDragDataImpl::SetReadOnly(bool read_only) {
   base::AutoLock lock_scope(lock_);
-  if (read_only_ == read_only)
+  if (read_only_ == read_only) {
     return;
+  }
 
   read_only_ = read_only;
 }
diff --git a/libcef/common/extensions/chrome_generated_schemas.cc b/libcef/common/extensions/chrome_generated_schemas.cc
index c62dad5cd..a89519ce5 100644
--- a/libcef/common/extensions/chrome_generated_schemas.cc
+++ b/libcef/common/extensions/chrome_generated_schemas.cc
@@ -14,15 +14,17 @@ namespace cef {
 
 // static
 base::StringPiece ChromeGeneratedSchemas::Get(const std::string& name) {
-  if (!ChromeFunctionRegistry::IsSupported(name))
+  if (!ChromeFunctionRegistry::IsSupported(name)) {
     return base::StringPiece();
+  }
   return extensions::api::ChromeGeneratedSchemas::Get(name);
 }
 
 // static
 bool ChromeGeneratedSchemas::IsGenerated(std::string name) {
-  if (!ChromeFunctionRegistry::IsSupported(name))
+  if (!ChromeFunctionRegistry::IsSupported(name)) {
     return false;
+  }
   return extensions::api::ChromeGeneratedSchemas::IsGenerated(name);
 }
 
diff --git a/libcef/common/extensions/extensions_api_provider.cc b/libcef/common/extensions/extensions_api_provider.cc
index 64df67c46..eb3767314 100644
--- a/libcef/common/extensions/extensions_api_provider.cc
+++ b/libcef/common/extensions/extensions_api_provider.cc
@@ -7,7 +7,7 @@
 #include "libcef/common/extensions/chrome_generated_schemas.h"
 
 #include "cef/grit/cef_resources.h"
-//#include "cef/libcef/common/extensions/api/generated_schemas.h"
+// #include "cef/libcef/common/extensions/api/generated_schemas.h"
 #include "cef/libcef/common/extensions/api/cef_api_features.h"
 #include "cef/libcef/common/extensions/api/cef_manifest_features.h"
 #include "cef/libcef/common/extensions/api/cef_permission_features.h"
@@ -52,8 +52,9 @@ bool CefExtensionsAPIProvider::IsAPISchemaGenerated(const std::string& name) {
   //   return true;
 
   // Chrome APIs whitelisted by CEF.
-  if (api::cef::ChromeGeneratedSchemas::IsGenerated(name))
+  if (api::cef::ChromeGeneratedSchemas::IsGenerated(name)) {
     return true;
+  }
 
   return false;
 }
@@ -67,8 +68,9 @@ base::StringPiece CefExtensionsAPIProvider::GetAPISchema(
   //   return api::cef::CefGeneratedSchemas::Get(name);
 
   // Chrome APIs whitelisted by CEF.
-  if (api::cef::ChromeGeneratedSchemas::IsGenerated(name))
+  if (api::cef::ChromeGeneratedSchemas::IsGenerated(name)) {
     return api::cef::ChromeGeneratedSchemas::Get(name);
+  }
 
   return base::StringPiece();
 }
diff --git a/libcef/common/extensions/extensions_util.cc b/libcef/common/extensions/extensions_util.cc
index aac929f39..f12653077 100644
--- a/libcef/common/extensions/extensions_util.cc
+++ b/libcef/common/extensions/extensions_util.cc
@@ -29,8 +29,9 @@ bool PrintPreviewEnabled() {
   // Not currently supported on macOS.
   return false;
 #else
-  if (!PdfExtensionEnabled())
+  if (!PdfExtensionEnabled()) {
     return false;
+  }
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisablePrintPreview)) {
diff --git a/libcef/common/file_util_impl.cc b/libcef/common/file_util_impl.cc
index ee9984ac3..e27609ae2 100644
--- a/libcef/common/file_util_impl.cc
+++ b/libcef/common/file_util_impl.cc
@@ -24,14 +24,16 @@ bool AllowFileIO() {
 }  // namespace
 
 bool CefCreateDirectory(const CefString& full_path) {
-  if (!AllowFileIO())
+  if (!AllowFileIO()) {
     return false;
+  }
   return base::CreateDirectory(full_path);
 }
 
 bool CefGetTempDirectory(CefString& temp_dir) {
-  if (!AllowFileIO())
+  if (!AllowFileIO()) {
     return false;
+  }
   base::FilePath result;
   if (base::GetTempDir(&result)) {
     temp_dir = result.value();
@@ -42,8 +44,9 @@ bool CefGetTempDirectory(CefString& temp_dir) {
 
 bool CefCreateNewTempDirectory(const CefString& prefix,
                                CefString& new_temp_path) {
-  if (!AllowFileIO())
+  if (!AllowFileIO()) {
     return false;
+  }
   base::FilePath result;
   if (base::CreateNewTempDirectory(prefix, &result)) {
     new_temp_path = result.value();
@@ -55,8 +58,9 @@ bool CefCreateNewTempDirectory(const CefString& prefix,
 bool CefCreateTempDirectoryInDirectory(const CefString& base_dir,
                                        const CefString& prefix,
                                        CefString& new_dir) {
-  if (!AllowFileIO())
+  if (!AllowFileIO()) {
     return false;
+  }
   base::FilePath result;
   if (base::CreateTemporaryDirInDir(base_dir, prefix, &result)) {
     new_dir = result.value();
@@ -66,14 +70,16 @@ bool CefCreateTempDirectoryInDirectory(const CefString& base_dir,
 }
 
 bool CefDirectoryExists(const CefString& path) {
-  if (!AllowFileIO())
+  if (!AllowFileIO()) {
     return false;
+  }
   return base::DirectoryExists(path);
 }
 
 bool CefDeleteFile(const CefString& path, bool recursive) {
-  if (!AllowFileIO())
+  if (!AllowFileIO()) {
     return false;
+  }
   if (recursive) {
     return base::DeletePathRecursively(path);
   } else {
@@ -84,7 +90,8 @@ bool CefDeleteFile(const CefString& path, bool recursive) {
 bool CefZipDirectory(const CefString& src_dir,
                      const CefString& dest_file,
                      bool include_hidden_files) {
-  if (!AllowFileIO())
+  if (!AllowFileIO()) {
     return false;
+  }
   return zip::Zip(src_dir, dest_file, include_hidden_files);
 }
diff --git a/libcef/common/json_impl.cc b/libcef/common/json_impl.cc
index a05940a17..13b141ff8 100644
--- a/libcef/common/json_impl.cc
+++ b/libcef/common/json_impl.cc
@@ -13,19 +13,23 @@ namespace {
 
 int GetJSONReaderOptions(cef_json_parser_options_t options) {
   int op = base::JSON_PARSE_RFC;
-  if (options & JSON_PARSER_ALLOW_TRAILING_COMMAS)
+  if (options & JSON_PARSER_ALLOW_TRAILING_COMMAS) {
     op |= base::JSON_ALLOW_TRAILING_COMMAS;
+  }
   return op;
 }
 
 int GetJSONWriterOptions(cef_json_writer_options_t options) {
   int op = 0;
-  if (options & JSON_WRITER_OMIT_BINARY_VALUES)
+  if (options & JSON_WRITER_OMIT_BINARY_VALUES) {
     op |= base::JSONWriter::OPTIONS_OMIT_BINARY_VALUES;
-  if (options & JSON_WRITER_OMIT_DOUBLE_TYPE_PRESERVATION)
+  }
+  if (options & JSON_WRITER_OMIT_DOUBLE_TYPE_PRESERVATION) {
     op |= base::JSONWriter::OPTIONS_OMIT_DOUBLE_TYPE_PRESERVATION;
-  if (options & JSON_WRITER_PRETTY_PRINT)
+  }
+  if (options & JSON_WRITER_PRETTY_PRINT) {
     op |= base::JSONWriter::OPTIONS_PRETTY_PRINT;
+  }
   return op;
 }
 
@@ -40,8 +44,9 @@ CefRefPtr<CefValue> CefParseJSON(const CefString& json_string,
 CefRefPtr<CefValue> CefParseJSON(const void* json,
                                  size_t json_size,
                                  cef_json_parser_options_t options) {
-  if (!json || json_size == 0)
+  if (!json || json_size == 0) {
     return nullptr;
+  }
   absl::optional<base::Value> parse_result = base::JSONReader::Read(
       base::StringPiece(static_cast<const char*>(json), json_size),
       GetJSONReaderOptions(options));
@@ -73,8 +78,9 @@ CefRefPtr<CefValue> CefParseJSONAndReturnError(
 
 CefString CefWriteJSON(CefRefPtr<CefValue> node,
                        cef_json_writer_options_t options) {
-  if (!node.get() || !node->IsValid())
+  if (!node.get() || !node->IsValid()) {
     return CefString();
+  }
 
   CefValueImpl* impl = static_cast<CefValueImpl*>(node.get());
   CefValueImpl::ScopedLockedValue scoped_value(impl);
diff --git a/libcef/common/net/http_header_utils.cc b/libcef/common/net/http_header_utils.cc
index 6199d2f94..60a7085de 100644
--- a/libcef/common/net/http_header_utils.cc
+++ b/libcef/common/net/http_header_utils.cc
@@ -24,8 +24,9 @@ std::string GenerateHeaders(const HeaderMap& map) {
 
     if (!key.empty()) {
       // Delimit with "\r\n".
-      if (!headers.empty())
+      if (!headers.empty()) {
         headers += "\r\n";
+      }
 
       headers += std::string(key) + ": " + std::string(value);
     }
@@ -50,8 +51,9 @@ void MakeASCIILower(std::string* str) {
 HeaderMap::iterator FindHeaderInMap(const std::string& nameLower,
                                     HeaderMap& map) {
   for (auto it = map.begin(); it != map.end(); ++it) {
-    if (base::EqualsCaseInsensitiveASCII(it->first.ToString(), nameLower))
+    if (base::EqualsCaseInsensitiveASCII(it->first.ToString(), nameLower)) {
       return it;
+    }
   }
 
   return map.end();
diff --git a/libcef/common/net/net_resource_provider.cc b/libcef/common/net/net_resource_provider.cc
index ee98b5783..eea3db750 100644
--- a/libcef/common/net/net_resource_provider.cc
+++ b/libcef/common/net/net_resource_provider.cc
@@ -10,7 +10,8 @@
 scoped_refptr<base::RefCountedMemory> NetResourceProvider(int key) {
   // Chrome performs substitution of localized strings for directory listings.
   scoped_refptr<base::RefCountedMemory> value = ChromeNetResourceProvider(key);
-  if (!value)
+  if (!value) {
     LOG(ERROR) << "No data resource available for id " << key;
+  }
   return value;
 }
diff --git a/libcef/common/net/scheme_registration.cc b/libcef/common/net/scheme_registration.cc
index b377b1a58..75569767e 100644
--- a/libcef/common/net/scheme_registration.cc
+++ b/libcef/common/net/scheme_registration.cc
@@ -17,8 +17,9 @@
 namespace scheme {
 
 void AddInternalSchemes(content::ContentClient::Schemes* schemes) {
-  if (!cef::IsAlloyRuntimeEnabled())
+  if (!cef::IsAlloyRuntimeEnabled()) {
     return;
+  }
 
   // chrome: and chrome-devtools: schemes are registered in
   // RenderThreadImpl::RegisterSchemes().
@@ -39,16 +40,21 @@ void AddInternalSchemes(content::ContentClient::Schemes* schemes) {
   // with Blink only.
   for (size_t i = 0; i < sizeof(internal_schemes) / sizeof(internal_schemes[0]);
        ++i) {
-    if (internal_schemes[i].is_standard)
+    if (internal_schemes[i].is_standard) {
       schemes->standard_schemes.push_back(internal_schemes[i].scheme_name);
-    if (internal_schemes[i].is_local)
+    }
+    if (internal_schemes[i].is_local) {
       schemes->local_schemes.push_back(internal_schemes[i].scheme_name);
-    if (internal_schemes[i].is_secure)
+    }
+    if (internal_schemes[i].is_secure) {
       schemes->secure_schemes.push_back(internal_schemes[i].scheme_name);
-    if (internal_schemes[i].is_cors_enabled)
+    }
+    if (internal_schemes[i].is_cors_enabled) {
       schemes->cors_enabled_schemes.push_back(internal_schemes[i].scheme_name);
-    if (internal_schemes[i].is_csp_bypassing)
+    }
+    if (internal_schemes[i].is_csp_bypassing) {
       schemes->csp_bypassing_schemes.push_back(internal_schemes[i].scheme_name);
+    }
     CefAppManager::Get()->AddCustomScheme(&internal_schemes[i]);
   }
 }
@@ -72,8 +78,9 @@ bool IsInternalHandledScheme(const std::string& scheme) {
   };
 
   for (size_t i = 0; i < sizeof(schemes) / sizeof(schemes[0]); ++i) {
-    if (scheme == schemes[i])
+    if (scheme == schemes[i]) {
       return true;
+    }
   }
 
   return false;
diff --git a/libcef/common/net/url_util.cc b/libcef/common/net/url_util.cc
index 0c45d174a..710601d8d 100644
--- a/libcef/common/net/url_util.cc
+++ b/libcef/common/net/url_util.cc
@@ -18,8 +18,9 @@ GURL MakeGURL(const CefString& url, bool fixup) {
     new_url.insert(0, fixed_scheme);
     gurl = GURL(new_url);
   }
-  if (fixup)
+  if (fixup) {
     FixupGURL(gurl);
+  }
   return gurl;
 }
 
diff --git a/libcef/common/net_service/net_service_util.cc b/libcef/common/net_service/net_service_util.cc
index 4e6d572d8..d8cd3eb85 100644
--- a/libcef/common/net_service/net_service_util.cc
+++ b/libcef/common/net_service/net_service_util.cc
@@ -34,8 +34,9 @@ bool GetCookieDomain(const GURL& url,
                      const net::ParsedCookie& pc,
                      std::string* result) {
   std::string domain_string;
-  if (pc.HasDomain())
+  if (pc.HasDomain()) {
     domain_string = pc.Domain();
+  }
   net::CookieInclusionStatus status;
   return net::cookie_util::GetCookieDomainWithString(url, domain_string, status,
                                                      result);
@@ -116,8 +117,9 @@ scoped_refptr<net::HttpResponseHeaders> MakeResponseHeaders(
     int64_t content_length,
     const std::multimap<std::string, std::string>& extra_headers,
     bool allow_existing_header_override) {
-  if (status_code <= 0)
+  if (status_code <= 0) {
     status_code = 200;
+  }
 
   auto headers = WrapRefCounted(new net::HttpResponseHeaders(
       MakeStatusLine(status_code, status_text, false)));
@@ -149,10 +151,11 @@ scoped_refptr<net::HttpResponseHeaders> MakeResponseHeaders(
       const std::string& name_lowercase = base::ToLowerASCII(pair.first);
       if (set_headers_lowercase.find(name_lowercase) !=
           set_headers_lowercase.end()) {
-        if (allow_existing_header_override)
+        if (allow_existing_header_override) {
           headers->RemoveHeader(pair.first);
-        else
+        } else {
           continue;
+        }
       }
     }
 
@@ -169,8 +172,9 @@ net::RedirectInfo MakeRedirectInfo(const network::ResourceRequest& request,
   bool insecure_scheme_was_upgraded = false;
 
   GURL location = new_location;
-  if (status_code == 0)
+  if (status_code == 0) {
     status_code = net::HTTP_TEMPORARY_REDIRECT;
+  }
 
   // If this a redirect to HTTP of a request that had the
   // 'upgrade-insecure-requests' policy set, upgrade it to HTTPS.
@@ -229,8 +233,9 @@ bool MakeCefCookie(const net::CanonicalCookie& cc, CefCookie& cookie) {
   cookie.creation = CefBaseTime(cc.CreationDate());
   cookie.last_access = CefBaseTime(cc.LastAccessDate());
   cookie.has_expires = cc.IsPersistent();
-  if (cookie.has_expires)
+  if (cookie.has_expires) {
     cookie.expires = CefBaseTime(cc.ExpiryDate());
+  }
   cookie.same_site = MakeCefCookieSameSite(cc.SameSite());
   cookie.priority = MakeCefCookiePriority(cc.Priority());
 
@@ -242,16 +247,19 @@ bool MakeCefCookie(const GURL& url,
                    CefCookie& cookie) {
   // Parse the cookie.
   net::ParsedCookie pc(cookie_line);
-  if (!pc.IsValid())
+  if (!pc.IsValid()) {
     return false;
+  }
 
   std::string cookie_domain;
-  if (!GetCookieDomain(url, pc, &cookie_domain))
+  if (!GetCookieDomain(url, pc, &cookie_domain)) {
     return false;
+  }
 
   std::string path_string;
-  if (pc.HasPath())
+  if (pc.HasPath()) {
     path_string = pc.Path();
+  }
   std::string cookie_path =
       net::CanonicalCookie::CanonPathWithString(url, path_string);
   base::Time creation_time = base::Time::Now();
@@ -267,8 +275,9 @@ bool MakeCefCookie(const GURL& url,
   cookie.creation = CefBaseTime(creation_time);
   cookie.last_access = CefBaseTime(creation_time);
   cookie.has_expires = !cookie_expires.is_null();
-  if (cookie.has_expires)
+  if (cookie.has_expires) {
     cookie.expires = CefBaseTime(cookie_expires);
+  }
   cookie.same_site = MakeCefCookieSameSite(pc.SameSite());
   cookie.priority = MakeCefCookiePriority(pc.Priority());
 
diff --git a/libcef/common/parser_impl.cc b/libcef/common/parser_impl.cc
index 825576121..c0e25c8f9 100644
--- a/libcef/common/parser_impl.cc
+++ b/libcef/common/parser_impl.cc
@@ -17,12 +17,14 @@ bool CefResolveURL(const CefString& base_url,
                    const CefString& relative_url,
                    CefString& resolved_url) {
   GURL base_gurl(base_url.ToString());
-  if (!base_gurl.is_valid())
+  if (!base_gurl.is_valid()) {
     return false;
+  }
 
   GURL combined_gurl = base_gurl.Resolve(relative_url.ToString());
-  if (!combined_gurl.is_valid())
+  if (!combined_gurl.is_valid()) {
     return false;
+  }
 
   resolved_url = combined_gurl.spec();
   return true;
@@ -30,8 +32,9 @@ bool CefResolveURL(const CefString& base_url,
 
 bool CefParseURL(const CefString& url, CefURLParts& parts) {
   GURL gurl(url.ToString());
-  if (!gurl.is_valid())
+  if (!gurl.is_valid()) {
     return false;
+  }
 
   CefString(&parts.spec).FromString(gurl.spec());
   CefString(&parts.scheme).FromString(gurl.scheme());
@@ -69,19 +72,24 @@ bool CefCreateURL(const CefURLParts& parts, CefString& url) {
     ss << scheme << "://";
     if (!username.empty()) {
       ss << username;
-      if (!password.empty())
+      if (!password.empty()) {
         ss << ":" << password;
+      }
       ss << "@";
     }
     ss << host;
-    if (!port.empty())
+    if (!port.empty()) {
       ss << ":" << port;
-    if (!path.empty())
+    }
+    if (!path.empty()) {
       ss << path;
-    if (!query.empty())
+    }
+    if (!query.empty()) {
       ss << "?" << query;
-    if (!fragment.empty())
+    }
+    if (!fragment.empty()) {
       ss << "#" << fragment;
+    }
     gurl = GURL(ss.str());
   }
 
@@ -114,13 +122,15 @@ void CefGetExtensionsForMimeType(const CefString& mime_type,
   VectorType ext;
   net::GetExtensionsForMimeType(mime_type, &ext);
   VectorType::const_iterator it = ext.begin();
-  for (; it != ext.end(); ++it)
+  for (; it != ext.end(); ++it) {
     extensions.push_back(*it);
+  }
 }
 
 CefString CefBase64Encode(const void* data, size_t data_size) {
-  if (data_size == 0)
+  if (data_size == 0) {
     return CefString();
+  }
 
   base::StringPiece input(static_cast<const char*>(data), data_size);
   std::string output;
@@ -129,13 +139,15 @@ CefString CefBase64Encode(const void* data, size_t data_size) {
 }
 
 CefRefPtr<CefBinaryValue> CefBase64Decode(const CefString& data) {
-  if (data.size() == 0)
+  if (data.size() == 0) {
     return nullptr;
+  }
 
   const std::string& input = data;
   std::string output;
-  if (base::Base64Decode(input, &output))
+  if (base::Base64Decode(input, &output)) {
     return CefBinaryValue::Create(output.data(), output.size());
+  }
   return nullptr;
 }
 
@@ -148,9 +160,10 @@ CefString CefURIDecode(const CefString& text,
                        cef_uri_unescape_rule_t unescape_rule) {
   const base::UnescapeRule::Type type =
       static_cast<base::UnescapeRule::Type>(unescape_rule);
-  if (convert_to_utf8)
+  if (convert_to_utf8) {
     return base::UnescapeAndDecodeUTF8URLComponentWithAdjustments(
         text.ToString(), type, nullptr);
-  else
+  } else {
     return base::UnescapeURLComponent(text.ToString(), type);
+  }
 }
diff --git a/libcef/common/process_message_impl.cc b/libcef/common/process_message_impl.cc
index c3c8a7fd0..19042b013 100644
--- a/libcef/common/process_message_impl.cc
+++ b/libcef/common/process_message_impl.cc
@@ -54,8 +54,9 @@ bool CefProcessMessageImpl::IsReadOnly() {
 }
 
 CefRefPtr<CefProcessMessage> CefProcessMessageImpl::Copy() {
-  if (!IsValid())
+  if (!IsValid()) {
     return nullptr;
+  }
   return new CefProcessMessageImpl(name_, arguments_->Copy());
 }
 
diff --git a/libcef/common/request_impl.cc b/libcef/common/request_impl.cc
index 718e62347..c2dcfb173 100644
--- a/libcef/common/request_impl.cc
+++ b/libcef/common/request_impl.cc
@@ -123,8 +123,9 @@ void GetHeaderMap(const net::HttpRequestHeaders& headers,
                   CefRequest::HeaderMap& map) {
   map.clear();
 
-  if (headers.IsEmpty())
+  if (headers.IsEmpty()) {
     return;
+  }
 
   net::HttpRequestHeaders::Iterator it(headers);
   while (it.GetNext()) {
@@ -287,8 +288,9 @@ CefString CefRequestImpl::GetHeaderByName(const CefString& name) {
   HttpHeaderUtils::MakeASCIILower(&nameLower);
 
   auto it = HttpHeaderUtils::FindHeaderInMap(nameLower, headermap_);
-  if (it != headermap_.end())
+  if (it != headermap_.end()) {
     return it->second;
+  }
 
   return CefString();
 }
@@ -312,8 +314,9 @@ void CefRequestImpl::SetHeaderByName(const CefString& name,
   // There may be multiple values, so remove any first.
   for (auto it = headermap_.begin(); it != headermap_.end();) {
     if (base::EqualsCaseInsensitiveASCII(it->first.ToString(), nameStr)) {
-      if (!overwrite)
+      if (!overwrite) {
         return;
+      }
       it = headermap_.erase(it);
     } else {
       ++it;
@@ -434,11 +437,13 @@ void CefRequestImpl::Get(network::ResourceRequest* request,
                          bool changed_only) const {
   base::AutoLock lock_scope(lock_);
 
-  if (ShouldSet(kChangedUrl, changed_only))
+  if (ShouldSet(kChangedUrl, changed_only)) {
     request->url = url_;
+  }
 
-  if (ShouldSet(kChangedMethod, changed_only))
+  if (ShouldSet(kChangedMethod, changed_only)) {
     request->method = method_;
+  }
 
   if (ShouldSet(kChangedReferrer, changed_only)) {
     request->referrer = referrer_url_;
@@ -547,8 +552,9 @@ void CefRequestImpl::Get(const cef::mojom::RequestParamsPtr& params,
                          blink::WebURLRequest& request) {
   request.SetUrl(params->url);
   request.SetRequestorOrigin(blink::WebSecurityOrigin::Create(params->url));
-  if (!params->method.empty())
+  if (!params->method.empty()) {
     request.SetHttpMethod(blink::WebString::FromASCII(params->method));
+  }
 
   if (params->referrer && params->referrer->url.is_valid()) {
     const blink::WebString& referrer =
@@ -593,8 +599,9 @@ void CefRequestImpl::Get(const cef::mojom::RequestParamsPtr& params,
         blink::GetWebHTTPBodyForRequestBody(*params->upload_data));
   }
 
-  if (!params->site_for_cookies.IsNull())
+  if (!params->site_for_cookies.IsNull()) {
     request.SetSiteForCookies(params->site_for_cookies);
+  }
 
   int flags = params->load_flags;
   if (!(flags & kURCachePolicyMask)) {
@@ -620,8 +627,9 @@ void CefRequestImpl::Get(cef::mojom::RequestParamsPtr& params) const {
   params->referrer = blink::mojom::Referrer::New(
       referrer_url_, NetReferrerPolicyToBlinkReferrerPolicy(referrer_policy_));
 
-  if (!headermap_.empty())
+  if (!headermap_.empty()) {
     params->headers = HttpHeaderUtils::GenerateHeaders(headermap_);
+  }
 
   if (postdata_) {
     CefPostDataImpl* impl = static_cast<CefPostDataImpl*>(postdata_.get());
@@ -634,23 +642,27 @@ void CefRequestImpl::Get(cef::mojom::RequestParamsPtr& params) const {
 
 void CefRequestImpl::SetReadOnly(bool read_only) {
   base::AutoLock lock_scope(lock_);
-  if (read_only_ == read_only)
+  if (read_only_ == read_only) {
     return;
+  }
 
   read_only_ = read_only;
 
-  if (postdata_.get())
+  if (postdata_.get()) {
     static_cast<CefPostDataImpl*>(postdata_.get())->SetReadOnly(read_only);
+  }
 }
 
 void CefRequestImpl::SetTrackChanges(bool track_changes,
                                      bool backup_on_change) {
   base::AutoLock lock_scope(lock_);
-  if (track_changes_ == track_changes)
+  if (track_changes_ == track_changes) {
     return;
+  }
 
-  if (!track_changes && backup_on_change_)
+  if (!track_changes && backup_on_change_) {
     backup_.reset();
+  }
 
   track_changes_ = track_changes;
   backup_on_change_ = track_changes ? backup_on_change : false;
@@ -667,28 +679,34 @@ void CefRequestImpl::RevertChanges() {
   DCHECK(!read_only_);
   DCHECK(track_changes_);
   DCHECK(backup_on_change_);
-  if (!backup_)
+  if (!backup_) {
     return;
+  }
 
   // Restore the original values if a backup exists.
-  if (backup_->backups_ & kChangedUrl)
+  if (backup_->backups_ & kChangedUrl) {
     url_ = backup_->url_;
-  if (backup_->backups_ & kChangedMethod)
+  }
+  if (backup_->backups_ & kChangedMethod) {
     method_ = backup_->method_;
+  }
   if (backup_->backups_ & kChangedReferrer) {
     referrer_url_ = backup_->referrer_url_;
     referrer_policy_ = backup_->referrer_policy_;
   }
-  if (backup_->backups_ & kChangedPostData)
+  if (backup_->backups_ & kChangedPostData) {
     postdata_ = backup_->postdata_;
+  }
   if (backup_->backups_ & kChangedHeaderMap) {
     DCHECK(backup_->headermap_);
     headermap_.swap(*backup_->headermap_);
   }
-  if (backup_->backups_ & kChangedFlags)
+  if (backup_->backups_ & kChangedFlags) {
     flags_ = backup_->flags_;
-  if (backup_->backups_ & kChangedSiteForCookies)
+  }
+  if (backup_->backups_ & kChangedSiteForCookies) {
     site_for_cookies_ = backup_->site_for_cookies_;
+  }
 
   backup_.reset();
 }
@@ -767,12 +785,14 @@ cef_referrer_policy_t CefRequestImpl::BlinkReferrerPolicyToNetReferrerPolicy(
 
 void CefRequestImpl::Changed(uint8_t changes) {
   lock_.AssertAcquired();
-  if (!track_changes_)
+  if (!track_changes_) {
     return;
+  }
 
   if (backup_on_change_) {
-    if (!backup_)
+    if (!backup_) {
       backup_.reset(new Backup());
+    }
 
     // Set the backup values if not already set.
     if ((changes & kChangedUrl) && !(backup_->backups_ & kChangedUrl)) {
@@ -820,16 +840,19 @@ bool CefRequestImpl::ShouldSet(uint8_t changes, bool changed_only) const {
   lock_.AssertAcquired();
 
   // Always change if changes are not being tracked.
-  if (!track_changes_)
+  if (!track_changes_) {
     return true;
+  }
 
   // Always change if changed-only was not requested.
-  if (!changed_only)
+  if (!changed_only) {
     return true;
+  }
 
   // Change if the |changes| bit flag has been set.
-  if ((changes_ & changes) == changes)
+  if ((changes_ & changes) == changes) {
     return true;
+  }
 
   if ((changes & kChangedPostData) == kChangedPostData) {
     // Change if the post data object was modified directly.
@@ -971,8 +994,9 @@ scoped_refptr<network::ResourceRequestBody> CefPostDataImpl::GetBody() const {
 
 void CefPostDataImpl::SetReadOnly(bool read_only) {
   base::AutoLock lock_scope(lock_);
-  if (read_only_ == read_only)
+  if (read_only_ == read_only) {
     return;
+  }
 
   read_only_ = read_only;
 
@@ -984,8 +1008,9 @@ void CefPostDataImpl::SetReadOnly(bool read_only) {
 
 void CefPostDataImpl::SetTrackChanges(bool track_changes) {
   base::AutoLock lock_scope(lock_);
-  if (track_changes_ == track_changes)
+  if (track_changes_ == track_changes) {
     return;
+  }
 
   track_changes_ = track_changes;
   has_changes_ = false;
@@ -999,13 +1024,15 @@ void CefPostDataImpl::SetTrackChanges(bool track_changes) {
 
 bool CefPostDataImpl::HasChanges() const {
   base::AutoLock lock_scope(lock_);
-  if (has_changes_)
+  if (has_changes_) {
     return true;
+  }
 
   ElementVector::const_iterator it = elements_.begin();
   for (; it != elements_.end(); ++it) {
-    if (static_cast<CefPostDataElementImpl*>(it->get())->HasChanges())
+    if (static_cast<CefPostDataElementImpl*>(it->get())->HasChanges()) {
       return true;
+    }
   }
 
   return false;
@@ -1013,8 +1040,9 @@ bool CefPostDataImpl::HasChanges() const {
 
 void CefPostDataImpl::Changed() {
   lock_.AssertAcquired();
-  if (track_changes_ && !has_changes_)
+  if (track_changes_ && !has_changes_) {
     has_changes_ = true;
+  }
 }
 
 // CefPostDataElement ---------------------------------------------------------
@@ -1076,8 +1104,9 @@ void CefPostDataElementImpl::SetToBytes(size_t size, const void* bytes) {
   // Assign the new data
   void* data = malloc(size);
   DCHECK(data != nullptr);
-  if (data == nullptr)
+  if (data == nullptr) {
     return;
+  }
 
   memcpy(data, bytes, size);
 
@@ -1097,8 +1126,9 @@ CefString CefPostDataElementImpl::GetFile() {
   base::AutoLock lock_scope(lock_);
   DCHECK(type_ == PDE_TYPE_FILE);
   CefString filename;
-  if (type_ == PDE_TYPE_FILE)
+  if (type_ == PDE_TYPE_FILE) {
     filename.FromString(data_.filename.str, data_.filename.length, false);
+  }
   return filename;
 }
 
@@ -1106,8 +1136,9 @@ size_t CefPostDataElementImpl::GetBytesCount() {
   base::AutoLock lock_scope(lock_);
   DCHECK(type_ == PDE_TYPE_BYTES);
   size_t size = 0;
-  if (type_ == PDE_TYPE_BYTES)
+  if (type_ == PDE_TYPE_BYTES) {
     size = data_.bytes.size;
+  }
   return size;
 }
 
@@ -1154,16 +1185,18 @@ void CefPostDataElementImpl::Get(network::ResourceRequestBody& body) const {
 
 void CefPostDataElementImpl::SetReadOnly(bool read_only) {
   base::AutoLock lock_scope(lock_);
-  if (read_only_ == read_only)
+  if (read_only_ == read_only) {
     return;
+  }
 
   read_only_ = read_only;
 }
 
 void CefPostDataElementImpl::SetTrackChanges(bool track_changes) {
   base::AutoLock lock_scope(lock_);
-  if (track_changes_ == track_changes)
+  if (track_changes_ == track_changes) {
     return;
+  }
 
   track_changes_ = track_changes;
   has_changes_ = false;
@@ -1176,18 +1209,21 @@ bool CefPostDataElementImpl::HasChanges() const {
 
 void CefPostDataElementImpl::Changed() {
   lock_.AssertAcquired();
-  if (track_changes_ && !has_changes_)
+  if (track_changes_ && !has_changes_) {
     has_changes_ = true;
+  }
 }
 
 void CefPostDataElementImpl::Cleanup() {
-  if (type_ == PDE_TYPE_EMPTY)
+  if (type_ == PDE_TYPE_EMPTY) {
     return;
+  }
 
-  if (type_ == PDE_TYPE_BYTES)
+  if (type_ == PDE_TYPE_BYTES) {
     free(data_.bytes.bytes);
-  else if (type_ == PDE_TYPE_FILE)
+  } else if (type_ == PDE_TYPE_FILE) {
     cef_string_clear(&data_.filename);
+  }
   type_ = PDE_TYPE_EMPTY;
   memset(&data_, 0, sizeof(data_));
 }
diff --git a/libcef/common/resource_bundle_delegate.cc b/libcef/common/resource_bundle_delegate.cc
index a98d1dbf5..bfa0da009 100644
--- a/libcef/common/resource_bundle_delegate.cc
+++ b/libcef/common/resource_bundle_delegate.cc
@@ -15,8 +15,9 @@ base::FilePath CefResourceBundleDelegate::GetPathForResourcePack(
 base::FilePath CefResourceBundleDelegate::GetPathForLocalePack(
     const base::FilePath& pack_path,
     const std::string& locale) {
-  if (!pack_loading_disabled_)
+  if (!pack_loading_disabled_) {
     return pack_path;
+  }
   return base::FilePath();
 }
 
@@ -74,8 +75,9 @@ bool CefResourceBundleDelegate::GetLocalizedString(
         application->GetResourceBundleHandler();
     if (handler.get()) {
       CefString cef_str;
-      if (handler->GetLocalizedString(message_id, cef_str))
+      if (handler->GetLocalizedString(message_id, cef_str)) {
         *value = cef_str;
+      }
     }
   }
 
diff --git a/libcef/common/resource_bundle_impl.cc b/libcef/common/resource_bundle_impl.cc
index 014d298c3..7af873b46 100644
--- a/libcef/common/resource_bundle_impl.cc
+++ b/libcef/common/resource_bundle_impl.cc
@@ -10,8 +10,9 @@
 CefResourceBundleImpl::CefResourceBundleImpl() {}
 
 CefString CefResourceBundleImpl::GetLocalizedString(int string_id) {
-  if (!ui::ResourceBundle::HasSharedInstance())
+  if (!ui::ResourceBundle::HasSharedInstance()) {
     return CefString();
+  }
 
   return ui::ResourceBundle::GetSharedInstance().GetLocalizedString(string_id);
 }
@@ -24,14 +25,16 @@ CefRefPtr<CefBinaryValue> CefResourceBundleImpl::GetDataResource(
 CefRefPtr<CefBinaryValue> CefResourceBundleImpl::GetDataResourceForScale(
     int resource_id,
     ScaleFactor scale_factor) {
-  if (!ui::ResourceBundle::HasSharedInstance())
+  if (!ui::ResourceBundle::HasSharedInstance()) {
     return nullptr;
+  }
 
   base::RefCountedMemory* result =
       ui::ResourceBundle::GetSharedInstance().LoadDataResourceBytesForScale(
           resource_id, static_cast<ui::ResourceScaleFactor>(scale_factor));
-  if (!result)
+  if (!result) {
     return nullptr;
+  }
 
   return CefBinaryValue::Create(result->data(), result->size());
 }
diff --git a/libcef/common/resource_util.cc b/libcef/common/resource_util.cc
index 7a6018363..88941b17e 100644
--- a/libcef/common/resource_util.cc
+++ b/libcef/common/resource_util.cc
@@ -57,8 +57,9 @@ bool GetDefaultUserDataDirectory(base::FilePath* result) {
 
 // Based on chrome/common/chrome_paths_mac.mm.
 bool GetDefaultUserDataDirectory(base::FilePath* result) {
-  if (!base::PathService::Get(base::DIR_APP_DATA, result))
+  if (!base::PathService::Get(base::DIR_APP_DATA, result)) {
     return false;
+  }
   *result = result->Append(FILE_PATH_LITERAL("CEF"));
   *result = result->Append(FILE_PATH_LITERAL("User Data"));
   return true;
@@ -68,8 +69,9 @@ bool GetDefaultUserDataDirectory(base::FilePath* result) {
 
 // Based on chrome/common/chrome_paths_win.cc.
 bool GetDefaultUserDataDirectory(base::FilePath* result) {
-  if (!base::PathService::Get(base::DIR_LOCAL_APP_DATA, result))
+  if (!base::PathService::Get(base::DIR_LOCAL_APP_DATA, result)) {
     return false;
+  }
   *result = result->Append(FILE_PATH_LITERAL("CEF"));
   *result = result->Append(FILE_PATH_LITERAL("User Data"));
   return true;
@@ -99,14 +101,17 @@ base::FilePath GetUserDataPath(CefSettings* settings,
   // This may be set for sub-processes.
   base::FilePath result =
       command_line->GetSwitchValuePath(switches::kUserDataDir);
-  if (!result.empty())
+  if (!result.empty()) {
     return result;
+  }
 
-  if (GetDefaultUserDataDirectory(&result))
+  if (GetDefaultUserDataDirectory(&result)) {
     return result;
+  }
 
-  if (base::PathService::Get(base::DIR_TEMP, &result))
+  if (base::PathService::Get(base::DIR_TEMP, &result)) {
     return result;
+  }
 
   NOTREACHED();
   return result;
@@ -138,8 +143,9 @@ bool GetDefaultDownloadDirectory(base::FilePath* result) {
 
 bool GetDefaultDownloadSafeDirectory(base::FilePath* result) {
   // Start with the default download directory.
-  if (!GetDefaultDownloadDirectory(result))
+  if (!GetDefaultDownloadDirectory(result)) {
     return false;
+  }
 
   if (DownloadPathIsDangerous(*result)) {
 #if BUILDFLAG(IS_WIN) || BUILDFLAG(IS_LINUX)
diff --git a/libcef/common/response_impl.cc b/libcef/common/response_impl.cc
index c55a17367..29e622702 100644
--- a/libcef/common/response_impl.cc
+++ b/libcef/common/response_impl.cc
@@ -104,8 +104,9 @@ CefString CefResponseImpl::GetHeaderByName(const CefString& name) {
   HttpHeaderUtils::MakeASCIILower(&nameLower);
 
   auto it = HttpHeaderUtils::FindHeaderInMap(nameLower, header_map_);
-  if (it != header_map_.end())
+  if (it != header_map_.end()) {
     return it->second;
+  }
 
   return CefString();
 }
@@ -122,8 +123,9 @@ void CefResponseImpl::SetHeaderByName(const CefString& name,
   // There may be multiple values, so remove any first.
   for (auto it = header_map_.begin(); it != header_map_.end();) {
     if (base::EqualsCaseInsensitiveASCII(it->first.ToString(), nameLower)) {
-      if (!overwrite)
+      if (!overwrite) {
         return;
+      }
       it = header_map_.erase(it);
     } else {
       ++it;
@@ -159,12 +161,14 @@ scoped_refptr<net::HttpResponseHeaders> CefResponseImpl::GetResponseHeaders() {
   base::AutoLock lock_scope(lock_);
 
   std::string mime_type = mime_type_;
-  if (mime_type.empty())
+  if (mime_type.empty()) {
     mime_type = "text/html";
+  }
 
   std::multimap<std::string, std::string> extra_headers;
-  for (const auto& pair : header_map_)
+  for (const auto& pair : header_map_) {
     extra_headers.insert(std::make_pair(pair.first, pair.second));
+  }
 
   return net_service::MakeResponseHeaders(
       status_code_, status_text_, mime_type, charset_, -1, extra_headers,
@@ -180,8 +184,9 @@ void CefResponseImpl::SetResponseHeaders(
 
   size_t iter = 0;
   std::string name, value;
-  while (headers.EnumerateHeaderLines(&iter, &name, &value))
+  while (headers.EnumerateHeaderLines(&iter, &name, &value)) {
     header_map_.insert(std::make_pair(name, value));
+  }
 
   status_code_ = headers.response_code();
   status_text_ = headers.GetStatusText();
diff --git a/libcef/common/scheme_registrar_impl.cc b/libcef/common/scheme_registrar_impl.cc
index bd8f762fe..112876eb9 100644
--- a/libcef/common/scheme_registrar_impl.cc
+++ b/libcef/common/scheme_registrar_impl.cc
@@ -18,8 +18,9 @@ namespace {
 
 void AppendArray(const std::vector<std::string>& source,
                  std::vector<std::string>* target) {
-  if (source.empty())
+  if (source.empty()) {
     return;
+  }
   target->insert(target->end(), source.begin(), source.end());
 }
 }  // namespace
@@ -46,16 +47,21 @@ bool CefSchemeRegistrarImpl::AddCustomScheme(const CefString& scheme_name,
 
   // The |is_display_isolated| value is excluded here because it's registered
   // with Blink only.
-  if (is_standard)
+  if (is_standard) {
     schemes_.standard_schemes.push_back(scheme);
-  if (is_local)
+  }
+  if (is_local) {
     schemes_.local_schemes.push_back(scheme);
-  if (is_secure)
+  }
+  if (is_secure) {
     schemes_.secure_schemes.push_back(scheme);
-  if (is_cors_enabled)
+  }
+  if (is_cors_enabled) {
     schemes_.cors_enabled_schemes.push_back(scheme);
-  if (is_csp_bypassing)
+  }
+  if (is_csp_bypassing) {
     schemes_.csp_bypassing_schemes.push_back(scheme);
+  }
 
   CefSchemeInfo scheme_info = {
       scheme,    is_standard,     is_local,         is_display_isolated,
diff --git a/libcef/common/string_list_impl.cc b/libcef/common/string_list_impl.cc
index 280085835..02c956538 100644
--- a/libcef/common/string_list_impl.cc
+++ b/libcef/common/string_list_impl.cc
@@ -29,8 +29,9 @@ CEF_EXPORT int cef_string_list_value(cef_string_list_t list,
   DCHECK(value);
   StringList* impl = reinterpret_cast<StringList*>(list);
   DCHECK_LT(index, impl->size());
-  if (index >= impl->size())
+  if (index >= impl->size()) {
     return false;
+  }
   const CefString& str = (*impl)[index];
   return cef_string_copy(str.c_str(), str.length(), value);
 }
diff --git a/libcef/common/string_map_impl.cc b/libcef/common/string_map_impl.cc
index d3e1c3e0c..e95dbd09f 100644
--- a/libcef/common/string_map_impl.cc
+++ b/libcef/common/string_map_impl.cc
@@ -29,8 +29,9 @@ CEF_EXPORT int cef_string_map_find(cef_string_map_t map,
   DCHECK(value);
   StringMap* impl = reinterpret_cast<StringMap*>(map);
   StringMap::const_iterator it = impl->find(CefString(key));
-  if (it == impl->end())
+  if (it == impl->end()) {
     return 0;
+  }
 
   const CefString& val = it->second;
   return cef_string_set(val.c_str(), val.length(), value, true);
@@ -43,13 +44,15 @@ CEF_EXPORT int cef_string_map_key(cef_string_map_t map,
   DCHECK(key);
   StringMap* impl = reinterpret_cast<StringMap*>(map);
   DCHECK_LT(index, impl->size());
-  if (index >= impl->size())
+  if (index >= impl->size()) {
     return 0;
+  }
 
   StringMap::const_iterator it = impl->begin();
   for (size_t ct = 0; it != impl->end(); ++it, ct++) {
-    if (ct == index)
+    if (ct == index) {
       return cef_string_set(it->first.c_str(), it->first.length(), key, true);
+    }
   }
   return 0;
 }
@@ -61,8 +64,9 @@ CEF_EXPORT int cef_string_map_value(cef_string_map_t map,
   DCHECK(value);
   StringMap* impl = reinterpret_cast<StringMap*>(map);
   DCHECK_LT(index, impl->size());
-  if (index >= impl->size())
+  if (index >= impl->size()) {
     return 0;
+  }
 
   StringMap::const_iterator it = impl->begin();
   for (size_t ct = 0; it != impl->end(); ++it, ct++) {
diff --git a/libcef/common/string_multimap_impl.cc b/libcef/common/string_multimap_impl.cc
index dff72a931..24ff2307e 100644
--- a/libcef/common/string_multimap_impl.cc
+++ b/libcef/common/string_multimap_impl.cc
@@ -42,18 +42,21 @@ CEF_EXPORT int cef_string_multimap_enumerate(cef_string_multimap_t map,
   CefString key_str(key);
 
   DCHECK_LT(value_index, impl->count(key_str));
-  if (value_index >= impl->count(key_str))
+  if (value_index >= impl->count(key_str)) {
     return 0;
+  }
 
   std::pair<StringMultimap::iterator, StringMultimap::iterator> range_it =
       impl->equal_range(key_str);
 
   size_t count = value_index;
-  while (count-- && range_it.first != range_it.second)
+  while (count-- && range_it.first != range_it.second) {
     range_it.first++;
+  }
 
-  if (range_it.first == range_it.second)
+  if (range_it.first == range_it.second) {
     return 0;
+  }
 
   const CefString& val = range_it.first->second;
   return cef_string_set(val.c_str(), val.length(), value, true);
@@ -66,13 +69,15 @@ CEF_EXPORT int cef_string_multimap_key(cef_string_multimap_t map,
   DCHECK(key);
   StringMultimap* impl = reinterpret_cast<StringMultimap*>(map);
   DCHECK_LT(index, impl->size());
-  if (index >= impl->size())
+  if (index >= impl->size()) {
     return 0;
+  }
 
   StringMultimap::const_iterator it = impl->begin();
   for (size_t ct = 0; it != impl->end(); ++it, ct++) {
-    if (ct == index)
+    if (ct == index) {
       return cef_string_set(it->first.c_str(), it->first.length(), key, true);
+    }
   }
   return 0;
 }
@@ -84,8 +89,9 @@ CEF_EXPORT int cef_string_multimap_value(cef_string_multimap_t map,
   DCHECK(value);
   StringMultimap* impl = reinterpret_cast<StringMultimap*>(map);
   DCHECK_LT(index, impl->size());
-  if (index >= impl->size())
+  if (index >= impl->size()) {
     return 0;
+  }
 
   StringMultimap::const_iterator it = impl->begin();
   for (size_t ct = 0; it != impl->end(); ++it, ct++) {
diff --git a/libcef/common/string_types_impl.cc b/libcef/common/string_types_impl.cc
index dd1cfe6e7..84cc81314 100644
--- a/libcef/common/string_types_impl.cc
+++ b/libcef/common/string_types_impl.cc
@@ -42,8 +42,9 @@ CEF_EXPORT int cef_string_wide_set(const wchar_t* src,
   if (copy) {
     if (src && src_len > 0) {
       output->str = new wchar_t[src_len + 1];
-      if (!output->str)
+      if (!output->str) {
         return 0;
+      }
 
       memcpy(output->str, src, src_len * sizeof(wchar_t));
       output->str[src_len] = 0;
@@ -66,8 +67,9 @@ CEF_EXPORT int cef_string_utf8_set(const char* src,
   if (copy) {
     if (src && src_len > 0) {
       output->str = new char[src_len + 1];
-      if (!output->str)
+      if (!output->str) {
         return 0;
+      }
 
       memcpy(output->str, src, src_len * sizeof(char));
       output->str[src_len] = 0;
@@ -91,8 +93,9 @@ CEF_EXPORT int cef_string_utf16_set(const char16* src,
   if (copy) {
     if (src && src_len > 0) {
       output->str = new char16[src_len + 1];
-      if (!output->str)
+      if (!output->str) {
         return 0;
+      }
 
       memcpy(output->str, src, src_len * sizeof(char16));
       output->str[src_len] = 0;
@@ -109,8 +112,9 @@ CEF_EXPORT int cef_string_utf16_set(const char16* src,
 
 CEF_EXPORT void cef_string_wide_clear(cef_string_wide_t* str) {
   DCHECK(str != nullptr);
-  if (str->dtor && str->str)
+  if (str->dtor && str->str) {
     str->dtor(str->str);
+  }
 
   str->str = nullptr;
   str->length = 0;
@@ -119,8 +123,9 @@ CEF_EXPORT void cef_string_wide_clear(cef_string_wide_t* str) {
 
 CEF_EXPORT void cef_string_utf8_clear(cef_string_utf8_t* str) {
   DCHECK(str != nullptr);
-  if (str->dtor && str->str)
+  if (str->dtor && str->str) {
     str->dtor(str->str);
+  }
 
   str->str = nullptr;
   str->length = 0;
@@ -129,8 +134,9 @@ CEF_EXPORT void cef_string_utf8_clear(cef_string_utf8_t* str) {
 
 CEF_EXPORT void cef_string_utf16_clear(cef_string_utf16_t* str) {
   DCHECK(str != nullptr);
-  if (str->dtor && str->str)
+  if (str->dtor && str->str) {
     str->dtor(str->str);
+  }
 
   str->str = nullptr;
   str->length = 0;
@@ -139,36 +145,41 @@ CEF_EXPORT void cef_string_utf16_clear(cef_string_utf16_t* str) {
 
 CEF_EXPORT int cef_string_wide_cmp(const cef_string_wide_t* str1,
                                    const cef_string_wide_t* str2) {
-  if (str1->length == 0 && str2->length == 0)
+  if (str1->length == 0 && str2->length == 0) {
     return 0;
+  }
   int r = wcsncmp(str1->str, str2->str, std::min(str1->length, str2->length));
   if (r == 0) {
-    if (str1->length > str2->length)
+    if (str1->length > str2->length) {
       return 1;
-    else if (str1->length < str2->length)
+    } else if (str1->length < str2->length) {
       return -1;
+    }
   }
   return r;
 }
 
 CEF_EXPORT int cef_string_utf8_cmp(const cef_string_utf8_t* str1,
                                    const cef_string_utf8_t* str2) {
-  if (str1->length == 0 && str2->length == 0)
+  if (str1->length == 0 && str2->length == 0) {
     return 0;
+  }
   int r = strncmp(str1->str, str2->str, std::min(str1->length, str2->length));
   if (r == 0) {
-    if (str1->length > str2->length)
+    if (str1->length > str2->length) {
       return 1;
-    else if (str1->length < str2->length)
+    } else if (str1->length < str2->length) {
       return -1;
+    }
   }
   return r;
 }
 
 CEF_EXPORT int cef_string_utf16_cmp(const cef_string_utf16_t* str1,
                                     const cef_string_utf16_t* str2) {
-  if (str1->length == 0 && str2->length == 0)
+  if (str1->length == 0 && str2->length == 0) {
     return 0;
+  }
 #if defined(WCHAR_T_IS_UTF32)
   int r = std::char_traits<std::u16string::value_type>::compare(
       reinterpret_cast<std::u16string::value_type*>(str1->str),
@@ -178,10 +189,11 @@ CEF_EXPORT int cef_string_utf16_cmp(const cef_string_utf16_t* str1,
   int r = wcsncmp(str1->str, str2->str, std::min(str1->length, str2->length));
 #endif
   if (r == 0) {
-    if (str1->length > str2->length)
+    if (str1->length > str2->length) {
       return 1;
-    else if (str1->length < str2->length)
+    } else if (str1->length < str2->length) {
       return -1;
+    }
   }
   return r;
 }
@@ -191,8 +203,9 @@ CEF_EXPORT int cef_string_wide_to_utf8(const wchar_t* src,
                                        cef_string_utf8_t* output) {
   std::string str;
   bool ret = base::WideToUTF8(src, src_len, &str);
-  if (!cef_string_utf8_set(str.c_str(), str.length(), output, true))
+  if (!cef_string_utf8_set(str.c_str(), str.length(), output, true)) {
     return false;
+  }
   return ret;
 }
 
@@ -201,8 +214,9 @@ CEF_EXPORT int cef_string_utf8_to_wide(const char* src,
                                        cef_string_wide_t* output) {
   std::wstring str;
   bool ret = base::UTF8ToWide(src, src_len, &str);
-  if (!cef_string_wide_set(str.c_str(), str.length(), output, true))
+  if (!cef_string_wide_set(str.c_str(), str.length(), output, true)) {
     return false;
+  }
   return ret;
 }
 
@@ -212,8 +226,9 @@ CEF_EXPORT int cef_string_wide_to_utf16(const wchar_t* src,
   std::u16string str;
   bool ret = base::WideToUTF16(src, src_len, &str);
   if (!cef_string_utf16_set(reinterpret_cast<const char16*>(str.c_str()),
-                            str.length(), output, true))
+                            str.length(), output, true)) {
     return false;
+  }
   return ret;
 }
 
@@ -223,8 +238,9 @@ CEF_EXPORT int cef_string_utf16_to_wide(const char16* src,
   std::wstring str;
   bool ret = base::UTF16ToWide(
       reinterpret_cast<const std::u16string::value_type*>(src), src_len, &str);
-  if (!cef_string_wide_set(str.c_str(), str.length(), output, true))
+  if (!cef_string_wide_set(str.c_str(), str.length(), output, true)) {
     return false;
+  }
   return ret;
 }
 
@@ -234,8 +250,9 @@ CEF_EXPORT int cef_string_utf8_to_utf16(const char* src,
   std::u16string str;
   bool ret = base::UTF8ToUTF16(src, src_len, &str);
   if (!cef_string_utf16_set(reinterpret_cast<const char16*>(str.c_str()),
-                            str.length(), output, true))
+                            str.length(), output, true)) {
     return false;
+  }
   return ret;
 }
 
@@ -245,8 +262,9 @@ CEF_EXPORT int cef_string_utf16_to_utf8(const char16* src,
   std::string str;
   bool ret = base::UTF16ToUTF8(
       reinterpret_cast<const std::u16string::value_type*>(src), src_len, &str);
-  if (!cef_string_utf8_set(str.c_str(), str.length(), output, true))
+  if (!cef_string_utf8_set(str.c_str(), str.length(), output, true)) {
     return false;
+  }
   return ret;
 }
 
diff --git a/libcef/common/task_runner_impl.cc b/libcef/common/task_runner_impl.cc
index efeef98bf..ab345c209 100644
--- a/libcef/common/task_runner_impl.cc
+++ b/libcef/common/task_runner_impl.cc
@@ -24,8 +24,9 @@ using content::BrowserThread;
 CefRefPtr<CefTaskRunner> CefTaskRunner::GetForCurrentThread() {
   scoped_refptr<base::SingleThreadTaskRunner> task_runner =
       CefTaskRunnerImpl::GetCurrentTaskRunner();
-  if (task_runner.get())
+  if (task_runner.get()) {
     return new CefTaskRunnerImpl(task_runner);
+  }
   return nullptr;
 }
 
@@ -33,8 +34,9 @@ CefRefPtr<CefTaskRunner> CefTaskRunner::GetForCurrentThread() {
 CefRefPtr<CefTaskRunner> CefTaskRunner::GetForThread(CefThreadId threadId) {
   scoped_refptr<base::SingleThreadTaskRunner> task_runner =
       CefTaskRunnerImpl::GetTaskRunner(threadId);
-  if (task_runner.get())
+  if (task_runner.get()) {
     return new CefTaskRunnerImpl(task_runner);
+  }
 
   LOG(WARNING) << "Invalid thread id " << threadId;
   return nullptr;
@@ -52,13 +54,15 @@ CefTaskRunnerImpl::CefTaskRunnerImpl(
 scoped_refptr<base::SingleThreadTaskRunner> CefTaskRunnerImpl::GetTaskRunner(
     CefThreadId threadId) {
   auto* manager = CefTaskRunnerManager::Get();
-  if (!manager)
+  if (!manager) {
     return nullptr;
+  }
 
   switch (threadId) {
     case TID_UI:
-      if (BrowserThread::IsThreadInitialized(BrowserThread::UI))
+      if (BrowserThread::IsThreadInitialized(BrowserThread::UI)) {
         return content::GetUIThreadTaskRunner({});
+      }
       break;
     case TID_FILE_BACKGROUND:
       return manager->GetBackgroundTaskRunner();
@@ -69,8 +73,9 @@ scoped_refptr<base::SingleThreadTaskRunner> CefTaskRunnerImpl::GetTaskRunner(
     case TID_PROCESS_LAUNCHER:
       return content::GetProcessLauncherTaskRunner();
     case TID_IO:
-      if (BrowserThread::IsThreadInitialized(BrowserThread::IO))
+      if (BrowserThread::IsThreadInitialized(BrowserThread::IO)) {
         return content::GetIOThreadTaskRunner({});
+      }
       break;
     case TID_RENDERER:
       return manager->GetRenderTaskRunner();
@@ -85,8 +90,9 @@ scoped_refptr<base::SingleThreadTaskRunner> CefTaskRunnerImpl::GetTaskRunner(
 scoped_refptr<base::SingleThreadTaskRunner>
 CefTaskRunnerImpl::GetCurrentTaskRunner() {
   auto* manager = CefTaskRunnerManager::Get();
-  if (!manager)
+  if (!manager) {
     return nullptr;
+  }
 
   // For named browser process threads return the same TaskRunner as
   // GetTaskRunner(). Otherwise BelongsToThread() will return incorrect results.
@@ -104,8 +110,9 @@ CefTaskRunnerImpl::GetCurrentTaskRunner() {
 
   // Check for a MessageLoopProxy. This covers all of the named browser and
   // render process threads, plus a few extra.
-  if (auto task_runner = base::ThreadTaskRunnerHandle::Get())
+  if (auto task_runner = base::ThreadTaskRunnerHandle::Get()) {
     return task_runner;
+  }
 
   // Check for a WebWorker thread.
   return manager->GetWebWorkerTaskRunner();
diff --git a/libcef/common/test/translator_test_impl.cc b/libcef/common/test/translator_test_impl.cc
index 2fa5b8db4..93a8d5e9b 100644
--- a/libcef/common/test/translator_test_impl.cc
+++ b/libcef/common/test/translator_test_impl.cc
@@ -244,14 +244,16 @@ class CefTranslatorTestImpl : public CefTranslatorTest {
   // PRIMITIVE LIST VALUES
 
   bool SetIntList(const std::vector<int>& val) override {
-    if (val.size() != 2U)
+    if (val.size() != 2U) {
       return false;
+    }
     return val[0] == TEST_INT_VAL && val[1] == TEST_INT_VAL2;
   }
 
   bool GetIntListByRef(IntList& val) override {
-    if (val.size() != GetIntListSize())
+    if (val.size() != GetIntListSize()) {
       return false;
+    }
     val.clear();
     val.push_back(TEST_INT_VAL);
     val.push_back(TEST_INT_VAL2);
@@ -273,15 +275,17 @@ class CefTranslatorTestImpl : public CefTranslatorTest {
   // STRING LIST VALUES
 
   bool SetStringList(const std::vector<CefString>& val) override {
-    if (val.size() != 3U)
+    if (val.size() != 3U) {
       return false;
+    }
     return val[0] == TEST_STRING_VAL && val[1] == TEST_STRING_VAL2 &&
            val[2] == TEST_STRING_VAL3;
   }
 
   bool GetStringListByRef(StringList& val) override {
-    if (val.size() != 0U)
+    if (val.size() != 0U) {
       return false;
+    }
     val.push_back(TEST_STRING_VAL);
     val.push_back(TEST_STRING_VAL2);
     val.push_back(TEST_STRING_VAL3);
@@ -291,26 +295,31 @@ class CefTranslatorTestImpl : public CefTranslatorTest {
   // STRING MAP VALUES
 
   bool SetStringMap(const StringMap& val) override {
-    if (val.size() != 3U)
+    if (val.size() != 3U) {
       return false;
+    }
 
     StringMap::const_iterator it;
 
     it = val.find(TEST_STRING_KEY);
-    if (it == val.end() || it->second != TEST_STRING_VAL)
+    if (it == val.end() || it->second != TEST_STRING_VAL) {
       return false;
+    }
     it = val.find(TEST_STRING_KEY2);
-    if (it == val.end() || it->second != TEST_STRING_VAL2)
+    if (it == val.end() || it->second != TEST_STRING_VAL2) {
       return false;
+    }
     it = val.find(TEST_STRING_KEY3);
-    if (it == val.end() || it->second != TEST_STRING_VAL3)
+    if (it == val.end() || it->second != TEST_STRING_VAL3) {
       return false;
+    }
     return true;
   }
 
   bool GetStringMapByRef(std::map<CefString, CefString>& val) override {
-    if (val.size() != 0U)
+    if (val.size() != 0U) {
       return false;
+    }
 
     val.insert(std::make_pair(TEST_STRING_KEY, TEST_STRING_VAL));
     val.insert(std::make_pair(TEST_STRING_KEY2, TEST_STRING_VAL2));
@@ -322,26 +331,31 @@ class CefTranslatorTestImpl : public CefTranslatorTest {
 
   bool SetStringMultimap(
       const std::multimap<CefString, CefString>& val) override {
-    if (val.size() != 3U)
+    if (val.size() != 3U) {
       return false;
+    }
 
     StringMultimap::const_iterator it;
 
     it = val.find(TEST_STRING_KEY);
-    if (it == val.end() || it->second != TEST_STRING_VAL)
+    if (it == val.end() || it->second != TEST_STRING_VAL) {
       return false;
+    }
     it = val.find(TEST_STRING_KEY2);
-    if (it == val.end() || it->second != TEST_STRING_VAL2)
+    if (it == val.end() || it->second != TEST_STRING_VAL2) {
       return false;
+    }
     it = val.find(TEST_STRING_KEY3);
-    if (it == val.end() || it->second != TEST_STRING_VAL3)
+    if (it == val.end() || it->second != TEST_STRING_VAL3) {
       return false;
+    }
     return true;
   }
 
   bool GetStringMultimapByRef(StringMultimap& val) override {
-    if (val.size() != 0U)
+    if (val.size() != 0U) {
       return false;
+    }
 
     val.insert(std::make_pair(TEST_STRING_KEY, TEST_STRING_VAL));
     val.insert(std::make_pair(TEST_STRING_KEY2, TEST_STRING_VAL2));
@@ -364,15 +378,17 @@ class CefTranslatorTestImpl : public CefTranslatorTest {
   // STRUCT LIST VALUES
 
   bool SetPointList(const std::vector<CefPoint>& val) override {
-    if (val.size() != 2U)
+    if (val.size() != 2U) {
       return false;
+    }
     return val[0].x == TEST_X_VAL && val[0].y == TEST_Y_VAL &&
            val[1].x == TEST_X_VAL2 && val[1].y == TEST_Y_VAL2;
   }
 
   bool GetPointListByRef(PointList& val) override {
-    if (val.size() != GetPointListSize())
+    if (val.size() != GetPointListSize()) {
       return false;
+    }
     val.clear();
     val.push_back(CefPoint(TEST_X_VAL, TEST_Y_VAL));
     val.push_back(CefPoint(TEST_X_VAL2, TEST_Y_VAL2));
@@ -413,16 +429,18 @@ class CefTranslatorTestImpl : public CefTranslatorTest {
       const std::vector<CefRefPtr<CefTranslatorTestRefPtrLibrary>>& val,
       int val1,
       int val2) override {
-    if (val.size() != 2U)
+    if (val.size() != 2U) {
       return false;
+    }
     return val[0]->GetValue() == val1 && val[1]->GetValue() == val2;
   }
 
   bool GetRefPtrLibraryListByRef(RefPtrLibraryList& val,
                                  int val1,
                                  int val2) override {
-    if (val.size() != GetRefPtrLibraryListSize())
+    if (val.size() != GetRefPtrLibraryListSize()) {
       return false;
+    }
     val.clear();
     val.push_back(new CefTranslatorTestRefPtrLibraryChildImpl(val1, 0));
     val.push_back(new CefTranslatorTestRefPtrLibraryImpl(val2));
@@ -458,8 +476,9 @@ class CefTranslatorTestImpl : public CefTranslatorTest {
       const std::vector<CefRefPtr<CefTranslatorTestRefPtrClient>>& val,
       int val1,
       int val2) override {
-    if (val.size() != 2U)
+    if (val.size() != 2U) {
       return false;
+    }
     return val[0]->GetValue() == val1 && val[1]->GetValue() == val2;
   }
 
@@ -467,8 +486,9 @@ class CefTranslatorTestImpl : public CefTranslatorTest {
       RefPtrClientList& val,
       CefRefPtr<CefTranslatorTestRefPtrClient> val1,
       CefRefPtr<CefTranslatorTestRefPtrClient> val2) override {
-    if (val.size() != GetRefPtrClientListSize())
+    if (val.size() != GetRefPtrClientListSize()) {
       return false;
+    }
     val.clear();
     val.push_back(val1);
     val.push_back(val2);
@@ -542,8 +562,9 @@ class CefTranslatorTestImpl : public CefTranslatorTest {
       const std::vector<CefRawPtr<CefTranslatorTestScopedLibrary>>& val,
       int val1,
       int val2) override {
-    if (val.size() != 2U)
+    if (val.size() != 2U) {
       return false;
+    }
     return val[0]->GetValue() == val1 && val[1]->GetValue() == val2;
   }
 
@@ -564,8 +585,9 @@ class CefTranslatorTestImpl : public CefTranslatorTest {
       const std::vector<CefRawPtr<CefTranslatorTestScopedClient>>& val,
       int val1,
       int val2) override {
-    if (val.size() != 2U)
+    if (val.size() != 2U) {
       return false;
+    }
     return val[0]->GetValue() == val1 && val[1]->GetValue() == val2;
   }
 
diff --git a/libcef/common/thread_impl.cc b/libcef/common/thread_impl.cc
index 268ba72bd..b974e986a 100644
--- a/libcef/common/thread_impl.cc
+++ b/libcef/common/thread_impl.cc
@@ -63,8 +63,9 @@ bool CefThreadImpl::Create(const CefString& display_name,
                            cef_com_init_mode_t com_init_mode) {
   owner_task_runner_ = CefTaskRunnerImpl::GetCurrentTaskRunner();
   DCHECK(owner_task_runner_);
-  if (!owner_task_runner_)
+  if (!owner_task_runner_) {
     return false;
+  }
 
   thread_.reset(new base::Thread(display_name));
 
@@ -99,8 +100,9 @@ bool CefThreadImpl::Create(const CefString& display_name,
 
 #if BUILDFLAG(IS_WIN)
   if (com_init_mode != COM_INIT_MODE_NONE) {
-    if (com_init_mode == COM_INIT_MODE_STA)
+    if (com_init_mode == COM_INIT_MODE_STA) {
       options.message_pump_type = base::MessagePumpType::UI;
+    }
     thread_->init_com_with_mta(com_init_mode == COM_INIT_MODE_MTA);
   }
 #endif
@@ -124,20 +126,23 @@ cef_platform_thread_id_t CefThreadImpl::GetPlatformThreadId() {
 }
 
 void CefThreadImpl::Stop() {
-  if (!owner_task_runner_)
+  if (!owner_task_runner_) {
     return;
+  }
   if (!owner_task_runner_->RunsTasksInCurrentSequence()) {
     NOTREACHED() << "called on invalid thread";
     return;
   }
 
-  if (thread_)
+  if (thread_) {
     StopAndDestroy(thread_.release());
+  }
 }
 
 bool CefThreadImpl::IsRunning() {
-  if (!owner_task_runner_)
+  if (!owner_task_runner_) {
     return false;
+  }
   if (!owner_task_runner_->RunsTasksInCurrentSequence()) {
     NOTREACHED() << "called on invalid thread";
     return false;
diff --git a/libcef/common/time_impl.cc b/libcef/common/time_impl.cc
index af3d914ce..b2981ac1d 100644
--- a/libcef/common/time_impl.cc
+++ b/libcef/common/time_impl.cc
@@ -40,8 +40,9 @@ void cef_time_to_basetime(const cef_time_t& cef_time, base::Time& time) {
 void cef_time_from_basetime(const base::Time& time, cef_time_t& cef_time) {
 #if BUILDFLAG(IS_WIN)
   int64_t t = time.ToDeltaSinceWindowsEpoch().InMicroseconds();
-  if (!CanConvertToFileTime(t))
+  if (!CanConvertToFileTime(t)) {
     return;
+  }
 #endif
 
   base::Time::Exploded exploded;
@@ -57,8 +58,9 @@ void cef_time_from_basetime(const base::Time& time, cef_time_t& cef_time) {
 }
 
 CEF_EXPORT int cef_time_to_timet(const cef_time_t* cef_time, time_t* time) {
-  if (!cef_time || !time)
+  if (!cef_time || !time) {
     return 0;
+  }
 
   base::Time base_time;
   cef_time_to_basetime(*cef_time, base_time);
@@ -67,8 +69,9 @@ CEF_EXPORT int cef_time_to_timet(const cef_time_t* cef_time, time_t* time) {
 }
 
 CEF_EXPORT int cef_time_from_timet(time_t time, cef_time_t* cef_time) {
-  if (!cef_time)
+  if (!cef_time) {
     return 0;
+  }
 
   base::Time base_time = base::Time::FromTimeT(time);
   cef_time_from_basetime(base_time, *cef_time);
@@ -76,8 +79,9 @@ CEF_EXPORT int cef_time_from_timet(time_t time, cef_time_t* cef_time) {
 }
 
 CEF_EXPORT int cef_time_to_doublet(const cef_time_t* cef_time, double* time) {
-  if (!cef_time || !time)
+  if (!cef_time || !time) {
     return 0;
+  }
 
   base::Time base_time;
   cef_time_to_basetime(*cef_time, base_time);
@@ -86,8 +90,9 @@ CEF_EXPORT int cef_time_to_doublet(const cef_time_t* cef_time, double* time) {
 }
 
 CEF_EXPORT int cef_time_from_doublet(double time, cef_time_t* cef_time) {
-  if (!cef_time)
+  if (!cef_time) {
     return 0;
+  }
 
   base::Time base_time = base::Time::FromDoubleT(time);
   cef_time_from_basetime(base_time, *cef_time);
@@ -95,8 +100,9 @@ CEF_EXPORT int cef_time_from_doublet(double time, cef_time_t* cef_time) {
 }
 
 CEF_EXPORT int cef_time_now(cef_time_t* cef_time) {
-  if (!cef_time)
+  if (!cef_time) {
     return 0;
+  }
 
   base::Time base_time = base::Time::Now();
   cef_time_from_basetime(base_time, *cef_time);
@@ -110,8 +116,9 @@ CEF_EXPORT cef_basetime_t cef_basetime_now() {
 CEF_EXPORT int cef_time_delta(const cef_time_t* cef_time1,
                               const cef_time_t* cef_time2,
                               long long* delta) {
-  if (!cef_time1 || !cef_time2 || !delta)
+  if (!cef_time1 || !cef_time2 || !delta) {
     return 0;
+  }
 
   base::Time base_time1, base_time2;
   cef_time_to_basetime(*cef_time1, base_time1);
@@ -124,8 +131,9 @@ CEF_EXPORT int cef_time_delta(const cef_time_t* cef_time1,
 
 CEF_EXPORT int cef_time_to_basetime(const cef_time_t* from,
                                     cef_basetime_t* to) {
-  if (!from || !to)
+  if (!from || !to) {
     return 0;
+  }
 
   base::Time::Exploded exploded;
   exploded.year = from->year;
@@ -144,8 +152,9 @@ CEF_EXPORT int cef_time_to_basetime(const cef_time_t* from,
 
 CEF_EXPORT int cef_time_from_basetime(const cef_basetime_t from,
                                       cef_time_t* to) {
-  if (!to)
+  if (!to) {
     return 0;
+  }
 
   base::Time time = CefBaseTime(from);
 
diff --git a/libcef/common/tracker.cc b/libcef/common/tracker.cc
index 5e5c509e4..499f6d8bd 100644
--- a/libcef/common/tracker.cc
+++ b/libcef/common/tracker.cc
@@ -11,26 +11,30 @@ CefTrackNode::CefTrackNode() : track_next_(nullptr), track_prev_(nullptr) {}
 CefTrackNode::~CefTrackNode() {}
 
 void CefTrackNode::InsertTrackPrev(CefTrackNode* object) {
-  if (track_prev_)
+  if (track_prev_) {
     track_prev_->SetTrackNext(object);
+  }
   object->SetTrackNext(this);
   object->SetTrackPrev(track_prev_);
   track_prev_ = object;
 }
 
 void CefTrackNode::InsertTrackNext(CefTrackNode* object) {
-  if (track_next_)
+  if (track_next_) {
     track_next_->SetTrackPrev(object);
+  }
   object->SetTrackPrev(this);
   object->SetTrackNext(track_next_);
   track_next_ = object;
 }
 
 void CefTrackNode::RemoveTracking() {
-  if (track_next_)
+  if (track_next_) {
     track_next_->SetTrackPrev(track_prev_);
-  if (track_prev_)
+  }
+  if (track_prev_) {
     track_prev_->SetTrackNext(track_next_);
+  }
   track_next_ = nullptr;
   track_prev_ = nullptr;
 }
diff --git a/libcef/common/urlrequest_impl.cc b/libcef/common/urlrequest_impl.cc
index 463ea5ee4..986889756 100644
--- a/libcef/common/urlrequest_impl.cc
+++ b/libcef/common/urlrequest_impl.cc
@@ -32,8 +32,9 @@ CefRefPtr<CefURLRequest> CefURLRequest::Create(
     // In the browser process.
     CefRefPtr<CefBrowserURLRequest> impl =
         new CefBrowserURLRequest(nullptr, request, client, request_context);
-    if (impl->Start())
+    if (impl->Start()) {
       return impl.get();
+    }
     return nullptr;
   } else {
     NOTREACHED() << "called in unsupported process";
diff --git a/libcef/common/util_linux.cc b/libcef/common/util_linux.cc
index f21edb39a..42513458f 100644
--- a/libcef/common/util_linux.cc
+++ b/libcef/common/util_linux.cc
@@ -18,8 +18,9 @@ void OverrideChildProcessPath() {
   base::FilePath child_process_path =
       base::CommandLine::ForCurrentProcess()->GetSwitchValuePath(
           switches::kBrowserSubprocessPath);
-  if (child_process_path.empty())
+  if (child_process_path.empty()) {
     return;
+  }
 
   // Used by ChildProcessHost::GetChildPath and PlatformCrashpadInitialization.
   base::PathService::Override(content::CHILD_PROCESS_EXE, child_process_path);
diff --git a/libcef/common/util_mac.mm b/libcef/common/util_mac.mm
index 8f9ed0a08..762f63551 100644
--- a/libcef/common/util_mac.mm
+++ b/libcef/common/util_mac.mm
@@ -23,8 +23,9 @@ namespace {
 // Returns the path to the Frameworks directory inside the top-level app bundle.
 base::FilePath GetFrameworksPath() {
   base::FilePath bundle_path = GetMainBundlePath();
-  if (bundle_path.empty())
+  if (bundle_path.empty()) {
     return base::FilePath();
+  }
 
   return bundle_path.Append(FILE_PATH_LITERAL("Contents"))
       .Append(FILE_PATH_LITERAL("Frameworks"));
@@ -79,12 +80,14 @@ base::FilePath GetFrameworkDirectory() {
   base::FilePath frameworks_path =
       base::CommandLine::ForCurrentProcess()->GetSwitchValuePath(
           switches::kFrameworkDirPath);
-  if (!frameworks_path.empty())
+  if (!frameworks_path.empty()) {
     return frameworks_path;
+  }
 
   frameworks_path = GetFrameworksPath();
-  if (frameworks_path.empty())
+  if (frameworks_path.empty()) {
     return base::FilePath();
+  }
 
   return frameworks_path.Append(GetFrameworkName())
       .AddExtension(FILE_PATH_LITERAL(".framework"));
@@ -92,8 +95,9 @@ base::FilePath GetFrameworkDirectory() {
 
 base::FilePath GetFrameworkResourcesDirectory() {
   base::FilePath frameworks_path = GetFrameworkDirectory();
-  if (frameworks_path.empty())
+  if (frameworks_path.empty()) {
     return base::FilePath();
+  }
 
   return frameworks_path.Append(FILE_PATH_LITERAL("Resources"));
 }
@@ -109,8 +113,9 @@ base::FilePath GetMainBundlePath() {
   base::FilePath main_bundle_path =
       base::CommandLine::ForCurrentProcess()->GetSwitchValuePath(
           switches::kMainBundlePath);
-  if (!main_bundle_path.empty())
+  if (!main_bundle_path.empty()) {
     return main_bundle_path;
+  }
 
   return base::mac::GetAppBundlePath(GetMainProcessPath());
 }
@@ -122,8 +127,9 @@ std::string GetMainBundleID() {
 
 base::FilePath GetMainResourcesDirectory() {
   base::FilePath bundle_path = GetMainBundlePath();
-  if (bundle_path.empty())
+  if (bundle_path.empty()) {
     return base::FilePath();
+  }
 
   return bundle_path.Append(FILE_PATH_LITERAL("Contents"))
       .Append(FILE_PATH_LITERAL("Resources"));
@@ -131,8 +137,9 @@ base::FilePath GetMainResourcesDirectory() {
 
 base::FilePath GetChildProcessPath() {
   base::FilePath frameworks_path = GetFrameworksPath();
-  if (frameworks_path.empty())
+  if (frameworks_path.empty()) {
     return base::FilePath();
+  }
 
   std::string exe_name = GetMainProcessPath().BaseName().value();
   return frameworks_path.Append(FILE_PATH_LITERAL(exe_name + " Helper.app"))
diff --git a/libcef/common/value_base.cc b/libcef/common/value_base.cc
index f8c741b69..55989be0a 100644
--- a/libcef/common/value_base.cc
+++ b/libcef/common/value_base.cc
@@ -62,8 +62,9 @@ void CefValueController::Remove(void* value, bool notify_object) {
     // Remove all references.
     if (reference_map_.size() > 0) {
       ReferenceMap::iterator it = reference_map_.begin();
-      for (; it != reference_map_.end(); ++it)
+      for (; it != reference_map_.end(); ++it) {
         it->second->OnControlRemoved();
+      }
       reference_map_.clear();
     }
 
@@ -73,8 +74,9 @@ void CefValueController::Remove(void* value, bool notify_object) {
     ReferenceMap::iterator it = reference_map_.find(value);
     if (it != reference_map_.end()) {
       // Remove the reference.
-      if (notify_object)
+      if (notify_object) {
         it->second->OnControlRemoved();
+      }
       reference_map_.erase(it);
     }
   }
@@ -90,8 +92,9 @@ CefValueController::Object* CefValueController::Get(void* value) {
     return owner_object_;
   } else {
     ReferenceMap::iterator it = reference_map_.find(value);
-    if (it != reference_map_.end())
+    if (it != reference_map_.end()) {
       return it->second;
+    }
     return nullptr;
   }
 }
@@ -120,12 +123,14 @@ void CefValueController::RemoveDependencies(void* value) {
   // Controller should already be locked.
   DCHECK(locked());
 
-  if (dependency_map_.empty())
+  if (dependency_map_.empty()) {
     return;
+  }
 
   DependencyMap::iterator it_dependency = dependency_map_.find(value);
-  if (it_dependency == dependency_map_.end())
+  if (it_dependency == dependency_map_.end()) {
     return;
+  }
 
   // Start with the set of dependencies for the current value.
   DependencySet remove_set = it_dependency->second;
@@ -189,8 +194,9 @@ void CefValueController::TakeFrom(CefValueController* other) {
         // Evaluate each child.
         DependencySet::iterator it_other_set = it_other->second.begin();
         for (; it_other_set != it_other->second.end(); ++it_other_set) {
-          if (it_me->second.find(*it_other_set) == it_me->second.end())
+          if (it_me->second.find(*it_other_set) == it_me->second.end()) {
             it_me->second.insert(*it_other_set);
+          }
         }
       }
     }
@@ -203,8 +209,9 @@ void CefValueController::Swap(void* old_value, void* new_value) {
   // Controller should already be locked.
   DCHECK(locked());
 
-  if (owner_value_ == old_value)
+  if (owner_value_ == old_value) {
     owner_value_ = new_value;
+  }
 
   if (!reference_map_.empty()) {
     ReferenceMap::iterator it = reference_map_.find(old_value);
diff --git a/libcef/common/value_base.h b/libcef/common/value_base.h
index eb5af8f19..3eb455b12 100644
--- a/libcef/common/value_base.h
+++ b/libcef/common/value_base.h
@@ -36,16 +36,18 @@ class CefValueController
     explicit AutoLock(CefValueController* impl)
         : impl_(impl), verified_(impl && impl->VerifyThread()) {
       DCHECK(impl);
-      if (verified_)
+      if (verified_) {
         impl_->lock();
+      }
     }
 
     AutoLock(const AutoLock&) = delete;
     AutoLock& operator=(const AutoLock&) = delete;
 
     ~AutoLock() {
-      if (verified_)
+      if (verified_) {
         impl_->unlock();
+      }
     }
 
     inline bool verified() { return verified_; }
@@ -270,8 +272,9 @@ class CefValueBase : public CefType, public CefValueController::Object {
       controller_->AddReference(value_, this);
 
       // Add a dependency on the parent value.
-      if (parent_value)
+      if (parent_value) {
         controller_->AddDependency(parent_value, value_);
+      }
     }
   }
 
@@ -279,8 +282,9 @@ class CefValueBase : public CefType, public CefValueController::Object {
   CefValueBase& operator=(const CefValueBase&) = delete;
 
   ~CefValueBase() override {
-    if (controller_.get() && value_)
+    if (controller_.get() && value_) {
       Delete();
+    }
   }
 
   // True if the underlying value is referenced instead of owned.
@@ -397,8 +401,9 @@ class CefValueBase : public CefType, public CefValueController::Object {
   // Used to indicate that this object owns the controller.
   inline void SetOwnsController() {
     CefValueController::AutoLock lock_scope(controller_.get());
-    if (lock_scope.verified())
+    if (lock_scope.verified()) {
       controller_->SetOwner(value_, this);
+    }
   }
 
   // Encapsulates value locking and verification logic.
diff --git a/libcef/common/values_impl.cc b/libcef/common/values_impl.cc
index aa350ef30..51b173f8f 100644
--- a/libcef/common/values_impl.cc
+++ b/libcef/common/values_impl.cc
@@ -134,12 +134,15 @@ void CefValueImpl::SwapValue(base::Value* new_value,
 bool CefValueImpl::IsValid() {
   base::AutoLock lock_scope(lock_);
 
-  if (binary_value_)
+  if (binary_value_) {
     return binary_value_->IsValid();
-  if (dictionary_value_)
+  }
+  if (dictionary_value_) {
     return dictionary_value_->IsValid();
-  if (list_value_)
+  }
+  if (list_value_) {
     return list_value_->IsValid();
+  }
 
   return (value_ != nullptr);
 }
@@ -147,12 +150,15 @@ bool CefValueImpl::IsValid() {
 bool CefValueImpl::IsOwned() {
   base::AutoLock lock_scope(lock_);
 
-  if (binary_value_)
+  if (binary_value_) {
     return binary_value_->IsOwned();
-  if (dictionary_value_)
+  }
+  if (dictionary_value_) {
     return dictionary_value_->IsOwned();
-  if (list_value_)
+  }
+  if (list_value_) {
     return list_value_->IsOwned();
+  }
 
   return false;
 }
@@ -160,58 +166,72 @@ bool CefValueImpl::IsOwned() {
 bool CefValueImpl::IsReadOnly() {
   base::AutoLock lock_scope(lock_);
 
-  if (binary_value_)
+  if (binary_value_) {
     return true;
-  if (dictionary_value_)
+  }
+  if (dictionary_value_) {
     return dictionary_value_->IsReadOnly();
-  if (list_value_)
+  }
+  if (list_value_) {
     return list_value_->IsReadOnly();
+  }
 
   return false;
 }
 
 bool CefValueImpl::IsSame(CefRefPtr<CefValue> that) {
-  if (that.get() == this)
+  if (that.get() == this) {
     return true;
-  if (!that.get() || that->GetType() != GetType())
+  }
+  if (!that.get() || that->GetType() != GetType()) {
     return false;
+  }
 
   CefValueImpl* impl = static_cast<CefValueImpl*>(that.get());
 
   base::AutoLock lock_scope(lock_);
   base::AutoLock lock_scope2(impl->lock_);
 
-  if (binary_value_)
+  if (binary_value_) {
     return binary_value_->IsSame(impl->binary_value_);
-  if (dictionary_value_)
+  }
+  if (dictionary_value_) {
     return dictionary_value_->IsSame(impl->dictionary_value_);
-  if (list_value_)
+  }
+  if (list_value_) {
     return list_value_->IsSame(impl->list_value_);
+  }
 
   // Simple types are never the same.
   return false;
 }
 
 bool CefValueImpl::IsEqual(CefRefPtr<CefValue> that) {
-  if (that.get() == this)
+  if (that.get() == this) {
     return true;
-  if (!that.get() || that->GetType() != GetType())
+  }
+  if (!that.get() || that->GetType() != GetType()) {
     return false;
+  }
 
   CefValueImpl* impl = static_cast<CefValueImpl*>(that.get());
 
   base::AutoLock lock_scope(lock_);
   base::AutoLock lock_scope2(impl->lock_);
 
-  if (binary_value_)
+  if (binary_value_) {
     return binary_value_->IsEqual(impl->binary_value_);
-  if (dictionary_value_)
+  }
+  if (dictionary_value_) {
     return dictionary_value_->IsEqual(impl->dictionary_value_);
-  if (list_value_)
+  }
+  if (list_value_) {
     return list_value_->IsEqual(impl->list_value_);
+  }
 
-  if (!value_)  // Invalid types are equal.
+  if (!value_) {  // Invalid types are equal.
     return true;
+  }
 
   return *value_ == *(impl->value_.get());
 }
@@ -219,14 +239,18 @@ bool CefValueImpl::IsEqual(CefRefPtr<CefValue> that) {
 CefRefPtr<CefValue> CefValueImpl::Copy() {
   base::AutoLock lock_scope(lock_);
 
-  if (binary_value_)
+  if (binary_value_) {
     return new CefValueImpl(binary_value_->Copy());
-  if (dictionary_value_)
+  }
+  if (dictionary_value_) {
     return new CefValueImpl(dictionary_value_->Copy(false));
-  if (list_value_)
+  }
+  if (list_value_) {
     return new CefValueImpl(list_value_->Copy());
-  if (value_)
+  }
+  if (value_) {
     return new CefValueImpl(new base::Value(value_->Clone()));
+  }
 
   return new CefValueImpl();
 }
@@ -234,12 +258,15 @@ CefRefPtr<CefValue> CefValueImpl::Copy() {
 CefValueType CefValueImpl::GetType() {
   base::AutoLock lock_scope(lock_);
 
-  if (binary_value_)
+  if (binary_value_) {
     return VTYPE_BINARY;
-  if (dictionary_value_)
+  }
+  if (dictionary_value_) {
     return VTYPE_DICTIONARY;
-  if (list_value_)
+  }
+  if (list_value_) {
     return VTYPE_LIST;
+  }
 
   if (value_) {
     switch (value_->type()) {
@@ -266,8 +293,9 @@ bool CefValueImpl::GetBool() {
   base::AutoLock lock_scope(lock_);
 
   bool ret_value = false;
-  if (value_ && value_->is_bool())
+  if (value_ && value_->is_bool()) {
     ret_value = value_->GetBool();
+  }
   return ret_value;
 }
 
@@ -275,8 +303,9 @@ int CefValueImpl::GetInt() {
   base::AutoLock lock_scope(lock_);
 
   int ret_value = 0;
-  if (value_ && value_->is_int())
+  if (value_ && value_->is_int()) {
     ret_value = value_->GetInt();
+  }
   return ret_value;
 }
 
@@ -284,8 +313,9 @@ double CefValueImpl::GetDouble() {
   base::AutoLock lock_scope(lock_);
 
   double ret_value = 0;
-  if (value_ && value_->is_double())
+  if (value_ && value_->is_double()) {
     ret_value = value_->GetDouble();
+  }
   return ret_value;
 }
 
@@ -293,8 +323,9 @@ CefString CefValueImpl::GetString() {
   base::AutoLock lock_scope(lock_);
 
   std::string ret_value;
-  if (value_ && value_->is_string())
+  if (value_ && value_->is_string()) {
     ret_value = value_->GetString();
+  }
   return ret_value;
 }
 
@@ -405,8 +436,9 @@ void CefValueImpl::AcquireLock() NO_THREAD_SAFETY_ANALYSIS {
   lock_.Acquire();
 
   CefValueController* controller = GetValueController();
-  if (controller)
+  if (controller) {
     controller->lock();
+  }
 }
 
 void CefValueImpl::ReleaseLock() NO_THREAD_SAFETY_ANALYSIS {
@@ -441,8 +473,9 @@ CefRefPtr<CefBinaryValue> CefBinaryValue::Create(const void* data,
                                                  size_t data_size) {
   DCHECK(data);
   DCHECK_GT(data_size, (size_t)0);
-  if (!data || data_size == 0)
+  if (!data || data_size == 0) {
     return nullptr;
+  }
 
   return new CefBinaryValueImpl(static_cast<char*>(const_cast<void*>(data)),
                                 data_size);
@@ -458,8 +491,9 @@ CefRefPtr<CefBinaryValue> CefBinaryValueImpl::GetOrCreateRef(
   DCHECK(controller);
 
   CefValueController::Object* object = controller->Get(value);
-  if (object)
+  if (object) {
     return static_cast<CefBinaryValueImpl*>(object);
+  }
 
   return new CefBinaryValueImpl(value, parent_value,
                                 CefBinaryValueImpl::kReference, controller);
@@ -513,8 +547,9 @@ bool CefBinaryValueImpl::IsEqualValue(const base::Value* that) {
 }
 
 base::Value* CefBinaryValueImpl::GetValueUnsafe() {
-  if (!VerifyAttached())
+  if (!VerifyAttached()) {
     return nullptr;
+  }
   controller()->AssertLockAcquired();
   return const_cast<base::Value*>(&const_value());
 }
@@ -528,10 +563,12 @@ bool CefBinaryValueImpl::IsOwned() {
 }
 
 bool CefBinaryValueImpl::IsSame(CefRefPtr<CefBinaryValue> that) {
-  if (!that.get())
+  if (!that.get()) {
     return false;
-  if (that.get() == this)
+  }
+  if (that.get() == this) {
     return true;
+  }
 
   CEF_VALUE_VERIFY_RETURN(false, false);
   return static_cast<CefBinaryValueImpl*>(that.get())
@@ -539,10 +576,12 @@ bool CefBinaryValueImpl::IsSame(CefRefPtr<CefBinaryValue> that) {
 }
 
 bool CefBinaryValueImpl::IsEqual(CefRefPtr<CefBinaryValue> that) {
-  if (!that.get())
+  if (!that.get()) {
     return false;
-  if (that.get() == this)
+  }
+  if (that.get() == this) {
     return true;
+  }
 
   CEF_VALUE_VERIFY_RETURN(false, false);
   return static_cast<CefBinaryValueImpl*>(that.get())
@@ -565,15 +604,17 @@ size_t CefBinaryValueImpl::GetData(void* buffer,
                                    size_t data_offset) {
   DCHECK(buffer);
   DCHECK_GT(buffer_size, (size_t)0);
-  if (!buffer || buffer_size == 0)
+  if (!buffer || buffer_size == 0) {
     return 0;
+  }
 
   CEF_VALUE_VERIFY_RETURN(false, 0);
 
   size_t size = const_value().GetBlob().size();
   DCHECK_LT(data_offset, size);
-  if (data_offset >= size)
+  if (data_offset >= size) {
     return 0;
+  }
 
   size = std::min(buffer_size, size - data_offset);
   auto* data = const_value().GetBlob().data();
@@ -605,8 +646,9 @@ CefRefPtr<CefDictionaryValue> CefDictionaryValueImpl::GetOrCreateRef(
     bool read_only,
     CefValueController* controller) {
   CefValueController::Object* object = controller->Get(value);
-  if (object)
+  if (object) {
     return static_cast<CefDictionaryValueImpl*>(object);
+  }
 
   return new CefDictionaryValueImpl(value, parent_value,
                                     CefDictionaryValueImpl::kReference,
@@ -656,8 +698,9 @@ bool CefDictionaryValueImpl::IsEqualValue(const base::DictionaryValue* that) {
 }
 
 base::DictionaryValue* CefDictionaryValueImpl::GetValueUnsafe() {
-  if (!VerifyAttached())
+  if (!VerifyAttached()) {
     return nullptr;
+  }
   controller()->AssertLockAcquired();
   return const_cast<base::DictionaryValue*>(&const_value());
 }
@@ -675,10 +718,12 @@ bool CefDictionaryValueImpl::IsReadOnly() {
 }
 
 bool CefDictionaryValueImpl::IsSame(CefRefPtr<CefDictionaryValue> that) {
-  if (!that.get())
+  if (!that.get()) {
     return false;
-  if (that.get() == this)
+  }
+  if (that.get() == this) {
     return true;
+  }
 
   CEF_VALUE_VERIFY_RETURN(false, false);
   return static_cast<CefDictionaryValueImpl*>(that.get())
@@ -686,10 +731,12 @@ bool CefDictionaryValueImpl::IsSame(CefRefPtr<CefDictionaryValue> that) {
 }
 
 bool CefDictionaryValueImpl::IsEqual(CefRefPtr<CefDictionaryValue> that) {
-  if (!that.get())
+  if (!that.get()) {
     return false;
-  if (that.get() == this)
+  }
+  if (that.get() == this) {
     return true;
+  }
 
   CEF_VALUE_VERIFY_RETURN(false, false);
   return static_cast<CefDictionaryValueImpl*>(that.get())
@@ -972,8 +1019,9 @@ bool CefDictionaryValueImpl::RemoveInternal(const CefString& key) {
   // comparison purposes.
   const base::Value* actual_value =
       const_value().FindKey(base::StringPiece(key));
-  if (!actual_value)
+  if (!actual_value) {
     return false;
+  }
 
   // |actual_value| is no longer valid after this call.
   absl::optional<base::Value> out_value =
@@ -1039,8 +1087,9 @@ CefRefPtr<CefListValue> CefListValueImpl::GetOrCreateRef(
     bool read_only,
     CefValueController* controller) {
   CefValueController::Object* object = controller->Get(value);
-  if (object)
+  if (object) {
     return static_cast<CefListValueImpl*>(object);
+  }
 
   return new CefListValueImpl(value, parent_value, CefListValueImpl::kReference,
                               read_only, controller);
@@ -1088,8 +1137,9 @@ bool CefListValueImpl::IsEqualValue(const base::ListValue* that) {
 }
 
 base::ListValue* CefListValueImpl::GetValueUnsafe() {
-  if (!VerifyAttached())
+  if (!VerifyAttached()) {
     return nullptr;
+  }
   controller()->AssertLockAcquired();
   return const_cast<base::ListValue*>(&const_value());
 }
@@ -1107,10 +1157,12 @@ bool CefListValueImpl::IsReadOnly() {
 }
 
 bool CefListValueImpl::IsSame(CefRefPtr<CefListValue> that) {
-  if (!that.get())
+  if (!that.get()) {
     return false;
-  if (that.get() == this)
+  }
+  if (that.get() == this) {
     return true;
+  }
 
   CEF_VALUE_VERIFY_RETURN(false, false);
   return static_cast<CefListValueImpl*>(that.get())
@@ -1118,10 +1170,12 @@ bool CefListValueImpl::IsSame(CefRefPtr<CefListValue> that) {
 }
 
 bool CefListValueImpl::IsEqual(CefRefPtr<CefListValue> that) {
-  if (!that.get())
+  if (!that.get()) {
     return false;
-  if (that.get() == this)
+  }
+  if (that.get() == this) {
     return true;
+  }
 
   CEF_VALUE_VERIFY_RETURN(false, false);
   return static_cast<CefListValueImpl*>(that.get())
@@ -1142,15 +1196,17 @@ bool CefListValueImpl::SetSize(size_t size) {
   size_t current_size = const_value().GetList().size();
   if (size < current_size) {
     // Clean up any values above the requested size.
-    for (size_t i = current_size - 1; i >= size; --i)
+    for (size_t i = current_size - 1; i >= size; --i) {
       RemoveInternal(i);
+    }
   } else if (size > 0) {
     // Expand the list size.
     // TODO: This approach seems inefficient. See https://crbug.com/1187066#c17
     // for background.
     auto& list = mutable_value()->GetList();
-    while (list.size() < size)
+    while (list.size() < size) {
       mutable_value()->Append(base::Value());
+    }
   }
   return true;
 }
@@ -1409,8 +1465,9 @@ bool CefListValueImpl::SetList(size_t index, CefRefPtr<CefListValue> value) {
 
 bool CefListValueImpl::RemoveInternal(size_t index) {
   auto& list = mutable_value()->GetList();
-  if (index >= list.size())
+  if (index >= list.size()) {
     return false;
+  }
 
   // The std::move() call below which removes the Value from the list will
   // return a new Value object with the moved contents of the Value that exists
@@ -1447,8 +1504,9 @@ base::Value* CefListValueImpl::SetInternal(size_t index, base::Value* value) {
       // Expand the list size.
       // TODO: This approach seems inefficient. See
       // https://crbug.com/1187066#c17 for background.
-      while (list.size() <= index)
+      while (list.size() <= index) {
         mutable_value()->Append(base::Value());
+      }
     }
     list[index] = std::move(*value);
   }
diff --git a/libcef/common/waitable_event_impl.cc b/libcef/common/waitable_event_impl.cc
index 720c49598..49f0ed0e2 100644
--- a/libcef/common/waitable_event_impl.cc
+++ b/libcef/common/waitable_event_impl.cc
@@ -49,13 +49,15 @@ bool CefWaitableEventImpl::IsSignaled() {
 }
 
 void CefWaitableEventImpl::Wait() {
-  if (!AllowWait())
+  if (!AllowWait()) {
     return;
+  }
   event_.Wait();
 }
 
 bool CefWaitableEventImpl::TimedWait(int64 max_ms) {
-  if (!AllowWait())
+  if (!AllowWait()) {
     return false;
+  }
   return event_.TimedWait(base::Milliseconds(max_ms));
 }
diff --git a/libcef/renderer/alloy/alloy_content_renderer_client.cc b/libcef/renderer/alloy/alloy_content_renderer_client.cc
index 5f408461d..6c0e7b22d 100644
--- a/libcef/renderer/alloy/alloy_content_renderer_client.cc
+++ b/libcef/renderer/alloy/alloy_content_renderer_client.cc
@@ -129,8 +129,9 @@ AlloyContentRendererClient* AlloyContentRendererClient::Get() {
 scoped_refptr<base::SingleThreadTaskRunner>
 AlloyContentRendererClient::GetCurrentTaskRunner() {
   // Check if currently on the render thread.
-  if (CEF_CURRENTLY_ON_RT())
+  if (CEF_CURRENTLY_ON_RT()) {
     return render_task_runner_;
+  }
   return nullptr;
 }
 
@@ -138,8 +139,9 @@ void AlloyContentRendererClient::RunSingleProcessCleanup() {
   DCHECK(content::RenderProcessHost::run_renderer_in_process());
 
   // Make sure the render thread was actually started.
-  if (!render_task_runner_.get())
+  if (!render_task_runner_.get()) {
     return;
+  }
 
   if (content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
     RunSingleProcessCleanupOnUIThread();
@@ -160,8 +162,9 @@ void AlloyContentRendererClient::RunSingleProcessCleanup() {
       base::AutoLock lock_scope(single_process_cleanup_lock_);
       complete = single_process_cleanup_complete_;
     }
-    if (!complete)
+    if (!complete) {
       base::PlatformThread::YieldCurrentThread();
+    }
   } while (!complete);
 }
 
@@ -218,16 +221,18 @@ void AlloyContentRendererClient::RenderThreadStarted() {
     // If the command-line switch is specified then set the value that will be
     // checked in RenderThreadImpl::Init(). Otherwise, remove the application-
     // level value.
-    if (command_line->HasSwitch(switches::kDisableScrollBounce))
+    if (command_line->HasSwitch(switches::kDisableScrollBounce)) {
       value.reset(base::SysUTF8ToCFStringRef("false"));
+    }
 
     CFPreferencesSetAppValue(key, value, kCFPreferencesCurrentApplication);
     CFPreferencesAppSynchronize(kCFPreferencesCurrentApplication);
   }
 #endif  // BUILDFLAG(IS_MAC)
 
-  if (extensions::ExtensionsEnabled())
+  if (extensions::ExtensionsEnabled()) {
     extensions_renderer_client_->RenderThreadStarted();
+  }
 }
 
 void AlloyContentRendererClient::ExposeInterfacesToBrowser(
@@ -317,8 +322,9 @@ bool AlloyContentRendererClient::IsPluginHandledExternally(
     const blink::WebElement& plugin_element,
     const GURL& original_url,
     const std::string& mime_type) {
-  if (!extensions::ExtensionsEnabled())
+  if (!extensions::ExtensionsEnabled()) {
     return false;
+  }
 
   DCHECK(plugin_element.HasHTMLTagName("object") ||
          plugin_element.HasHTMLTagName("embed"));
@@ -390,8 +396,9 @@ void AlloyContentRendererClient::WillSendRequest(
     extensions_renderer_client_->WillSendRequest(frame, transition_type, url,
                                                  site_for_cookies,
                                                  initiator_origin, new_url);
-    if (!new_url->is_empty())
+    if (!new_url->is_empty()) {
       return;
+    }
   }
 }
 
@@ -417,20 +424,23 @@ void AlloyContentRendererClient::GetSupportedKeySystems(
 
 void AlloyContentRendererClient::RunScriptsAtDocumentStart(
     content::RenderFrame* render_frame) {
-  if (extensions::ExtensionsEnabled())
+  if (extensions::ExtensionsEnabled()) {
     extensions_renderer_client_->RunScriptsAtDocumentStart(render_frame);
+  }
 }
 
 void AlloyContentRendererClient::RunScriptsAtDocumentEnd(
     content::RenderFrame* render_frame) {
-  if (extensions::ExtensionsEnabled())
+  if (extensions::ExtensionsEnabled()) {
     extensions_renderer_client_->RunScriptsAtDocumentEnd(render_frame);
+  }
 }
 
 void AlloyContentRendererClient::RunScriptsAtDocumentIdle(
     content::RenderFrame* render_frame) {
-  if (extensions::ExtensionsEnabled())
+  if (extensions::ExtensionsEnabled()) {
     extensions_renderer_client_->RunScriptsAtDocumentIdle(render_frame);
+  }
 }
 
 void AlloyContentRendererClient::DevToolsAgentAttached() {
@@ -468,30 +478,34 @@ AlloyContentRendererClient::CreateURLLoaderThrottleProvider(
 void AlloyContentRendererClient::AppendContentSecurityPolicy(
     const blink::WebURL& url,
     blink::WebVector<blink::WebContentSecurityPolicyHeader>* csp) {
-  if (!extensions::ExtensionsEnabled())
+  if (!extensions::ExtensionsEnabled()) {
     return;
+  }
 
   // Don't apply default CSP to PDF renderers.
   // TODO(crbug.com/1252096): Lock down the CSP once style and script are no
   // longer injected inline by `pdf::PluginResponseWriter`. That class may be a
   // better place to define such CSP, or we may continue doing so here.
-  if (pdf::IsPdfRenderer())
+  if (pdf::IsPdfRenderer()) {
     return;
+  }
 
   DCHECK(csp);
   GURL gurl(url);
   const extensions::Extension* extension =
       extensions::RendererExtensionRegistry::Get()->GetExtensionOrAppByURL(
           gurl);
-  if (!extension)
+  if (!extension) {
     return;
+  }
 
   // Append a minimum CSP to ensure the extension can't relax the default
   // applied CSP through means like Service Worker.
   const std::string* default_csp =
       extensions::CSPInfo::GetMinimumCSPToAppend(*extension, gurl.path());
-  if (!default_csp)
+  if (!default_csp) {
     return;
+  }
 
   csp->push_back({blink::WebString::FromUTF8(*default_csp),
                   network::mojom::ContentSecurityPolicyType::kEnforce,
@@ -554,8 +568,9 @@ void AlloyContentRendererClient::RunSingleProcessCleanupOnUIThread() {
   // this task will only execute when running in multi-threaded message loop
   // mode (because otherwise the UI message loop has already stopped). Therefore
   // we need to explicitly delete the object when not running in this mode.
-  if (!CefContext::Get()->settings().multi_threaded_message_loop)
+  if (!CefContext::Get()->settings().multi_threaded_message_loop) {
     delete host;
+  }
 }
 
 // Enable deprecation warnings on Windows. See http://crbug.com/585142.
diff --git a/libcef/renderer/blink_glue.cc b/libcef/renderer/blink_glue.cc
index a0cbcc2bf..09875a03d 100644
--- a/libcef/renderer/blink_glue.cc
+++ b/libcef/renderer/blink_glue.cc
@@ -49,20 +49,23 @@ namespace blink_glue {
 const int64_t kInvalidFrameId = -1;
 
 bool CanGoBack(blink::WebView* view) {
-  if (!view)
+  if (!view) {
     return false;
+  }
   return view->HistoryBackListCount() > 0;
 }
 
 bool CanGoForward(blink::WebView* view) {
-  if (!view)
+  if (!view) {
     return false;
+  }
   return view->HistoryForwardListCount() > 0;
 }
 
 void GoBack(blink::WebView* view) {
-  if (!view)
+  if (!view) {
     return;
+  }
 
   blink::WebFrame* main_frame = view->MainFrame();
   if (main_frame && main_frame->IsWebLocalFrame()) {
@@ -76,8 +79,9 @@ void GoBack(blink::WebView* view) {
 }
 
 void GoForward(blink::WebView* view) {
-  if (!view)
+  if (!view) {
     return;
+  }
 
   blink::WebFrame* main_frame = view->MainFrame();
   if (main_frame && main_frame->IsWebLocalFrame()) {
@@ -102,8 +106,9 @@ blink::WebString DumpDocumentText(blink::WebLocalFrame* frame) {
   // We use the document element's text instead of the body text here because
   // not all documents have a body, such as XML documents.
   blink::WebElement document_element = frame->GetDocument().DocumentElement();
-  if (document_element.IsNull())
+  if (document_element.IsNull()) {
     return blink::WebString();
+  }
 
   blink::Element* web_element = document_element.Unwrap<blink::Element>();
   return blink::WebString(web_element->innerText());
@@ -188,12 +193,14 @@ v8::Local<v8::Value> ExecuteV8ScriptAndReturnValue(
     int start_line,
     v8::Local<v8::Context> context,
     v8::TryCatch& tryCatch) {
-  if (start_line < 1)
+  if (start_line < 1) {
     start_line = 1;
+  }
 
   blink::LocalFrame* frame = blink::ToLocalFrameIfNotDetached(context);
-  if (!frame)
+  if (!frame) {
     return v8::Local<v8::Value>();
+  }
 
   auto* script = blink::ClassicScript::Create(
       source, blink::KURL(source_url), blink::KURL(source_url),
diff --git a/libcef/renderer/browser_impl.cc b/libcef/renderer/browser_impl.cc
index 3efb0bc36..32628c454 100644
--- a/libcef/renderer/browser_impl.cc
+++ b/libcef/renderer/browser_impl.cc
@@ -86,8 +86,9 @@ bool CefBrowserImpl::IsLoading() {
 
   if (GetWebView()) {
     blink::WebFrame* main_frame = GetWebView()->MainFrame();
-    if (main_frame)
+    if (main_frame) {
       return main_frame->ToWebLocalFrame()->IsLoading();
+    }
   }
   return false;
 }
@@ -194,8 +195,9 @@ CefRefPtr<CefFrame> CefBrowserImpl::GetFrame(const CefString& name) {
         blink::WebString::FromUTF16(name.ToString16());
     // Search by assigned frame name (Frame::name).
     blink::WebFrame* frame = web_view->MainFrame();
-    if (frame && frame->IsWebLocalFrame())
+    if (frame && frame->IsWebLocalFrame()) {
       frame = frame->ToWebLocalFrame()->FindFrameByName(frame_name);
+    }
     if (!frame) {
       // Search by unique frame name (Frame::uniqueName).
       const std::string& searchname = name;
@@ -209,8 +211,9 @@ CefRefPtr<CefFrame> CefBrowserImpl::GetFrame(const CefString& name) {
         }
       }
     }
-    if (frame && frame->IsWebLocalFrame())
+    if (frame && frame->IsWebLocalFrame()) {
       return GetWebFrameImpl(frame->ToWebLocalFrame()).get();
+    }
   }
 
   return nullptr;
@@ -234,15 +237,17 @@ size_t CefBrowserImpl::GetFrameCount() {
 void CefBrowserImpl::GetFrameIdentifiers(std::vector<int64>& identifiers) {
   CEF_REQUIRE_RT_RETURN_VOID();
 
-  if (identifiers.size() > 0)
+  if (identifiers.size() > 0) {
     identifiers.clear();
+  }
 
   if (GetWebView()) {
     for (blink::WebFrame* frame = GetWebView()->MainFrame(); frame;
          frame = frame->TraverseNext()) {
-      if (frame->IsWebLocalFrame())
+      if (frame->IsWebLocalFrame()) {
         identifiers.push_back(
             render_frame_util::GetIdentifier(frame->ToWebLocalFrame()));
+      }
     }
   }
 }
@@ -250,14 +255,16 @@ void CefBrowserImpl::GetFrameIdentifiers(std::vector<int64>& identifiers) {
 void CefBrowserImpl::GetFrameNames(std::vector<CefString>& names) {
   CEF_REQUIRE_RT_RETURN_VOID();
 
-  if (names.size() > 0)
+  if (names.size() > 0) {
     names.clear();
+  }
 
   if (GetWebView()) {
     for (blink::WebFrame* frame = GetWebView()->MainFrame(); frame;
          frame = frame->TraverseNext()) {
-      if (frame->IsWebLocalFrame())
+      if (frame->IsWebLocalFrame()) {
         names.push_back(render_frame_util::GetName(frame->ToWebLocalFrame()));
+      }
     }
   }
 }
@@ -283,8 +290,9 @@ CefRefPtr<CefFrameImpl> CefBrowserImpl::GetWebFrameImpl(
 
   // Frames are re-used between page loads. Only add the frame to the map once.
   FrameMap::const_iterator it = frames_.find(frame_id);
-  if (it != frames_.end())
+  if (it != frames_.end()) {
     return it->second;
+  }
 
   CefRefPtr<CefFrameImpl> framePtr(new CefFrameImpl(this, frame, frame_id));
   frames_.insert(std::make_pair(frame_id, framePtr));
@@ -305,8 +313,9 @@ CefRefPtr<CefFrameImpl> CefBrowserImpl::GetWebFrameImpl(int64_t frame_id) {
 
   // Check if we already know about the frame.
   FrameMap::const_iterator it = frames_.find(frame_id);
-  if (it != frames_.end())
+  if (it != frames_.end()) {
     return it->second;
+  }
 
   if (GetWebView()) {
     // Check if the frame exists but we don't know about it yet.
@@ -329,8 +338,9 @@ void CefBrowserImpl::AddFrameObject(int64_t frame_id,
 
   if (!frame_objects_.empty()) {
     FrameObjectMap::const_iterator it = frame_objects_.find(frame_id);
-    if (it != frame_objects_.end())
+    if (it != frame_objects_.end()) {
       manager = it->second;
+    }
   }
 
   if (!manager.get()) {
@@ -349,8 +359,9 @@ void CefBrowserImpl::OnDestruct() {
   CefRefPtr<CefApp> app = CefAppManager::Get()->GetApplication();
   if (app.get()) {
     CefRefPtr<CefRenderProcessHandler> handler = app->GetRenderProcessHandler();
-    if (handler.get())
+    if (handler.get()) {
       handler->OnBrowserDestroyed(this);
+    }
   }
 
   CefRenderManager::Get()->OnBrowserDestroyed(this);
@@ -368,8 +379,9 @@ void CefBrowserImpl::FrameDetached(int64_t frame_id) {
   if (!frame_objects_.empty()) {
     // Remove any tracked objects associated with the frame.
     FrameObjectMap::iterator it = frame_objects_.find(frame_id);
-    if (it != frame_objects_.end())
+    if (it != frame_objects_.end()) {
       frame_objects_.erase(it);
+    }
   }
 }
 
diff --git a/libcef/renderer/chrome/chrome_content_renderer_client_cef.cc b/libcef/renderer/chrome/chrome_content_renderer_client_cef.cc
index eed95483b..576b5eb9a 100644
--- a/libcef/renderer/chrome/chrome_content_renderer_client_cef.cc
+++ b/libcef/renderer/chrome/chrome_content_renderer_client_cef.cc
@@ -19,8 +19,9 @@ ChromeContentRendererClientCef::~ChromeContentRendererClientCef() = default;
 scoped_refptr<base::SingleThreadTaskRunner>
 ChromeContentRendererClientCef::GetCurrentTaskRunner() {
   // Check if currently on the render thread.
-  if (CEF_CURRENTLY_ON_RT())
+  if (CEF_CURRENTLY_ON_RT()) {
     return render_task_runner_;
+  }
   return nullptr;
 }
 
diff --git a/libcef/renderer/dom_document_impl.cc b/libcef/renderer/dom_document_impl.cc
index 4685cffae..223462da5 100644
--- a/libcef/renderer/dom_document_impl.cc
+++ b/libcef/renderer/dom_document_impl.cc
@@ -38,16 +38,20 @@ CefDOMDocumentImpl::~CefDOMDocumentImpl() {
 }
 
 CefDOMDocumentImpl::Type CefDOMDocumentImpl::GetType() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return DOM_DOCUMENT_TYPE_UNKNOWN;
+  }
 
   const WebDocument& document = frame_->GetDocument();
-  if (document.IsHTMLDocument())
+  if (document.IsHTMLDocument()) {
     return DOM_DOCUMENT_TYPE_HTML;
-  if (document.IsXHTMLDocument())
+  }
+  if (document.IsXHTMLDocument()) {
     return DOM_DOCUMENT_TYPE_XHTML;
-  if (document.IsPluginDocument())
+  }
+  if (document.IsPluginDocument()) {
     return DOM_DOCUMENT_TYPE_PLUGIN;
+  }
   return DOM_DOCUMENT_TYPE_UNKNOWN;
 }
 
@@ -68,13 +72,15 @@ CefRefPtr<CefDOMNode> CefDOMDocumentImpl::GetHead() {
 
 CefString CefDOMDocumentImpl::GetTitle() {
   CefString str;
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return str;
+  }
 
   const WebDocument& document = frame_->GetDocument();
   const WebString& title = document.Title();
-  if (!title.IsNull())
+  if (!title.IsNull()) {
     str = title.Utf16();
+  }
 
   return str;
 }
@@ -91,74 +97,88 @@ CefRefPtr<CefDOMNode> CefDOMDocumentImpl::GetFocusedNode() {
 }
 
 bool CefDOMDocumentImpl::HasSelection() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   return frame_->HasSelection();
 }
 
 int CefDOMDocumentImpl::GetSelectionStartOffset() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return 0;
+  }
 
-  if (!frame_->HasSelection())
+  if (!frame_->HasSelection()) {
     return 0;
+  }
 
   const WebRange& range = frame_->SelectionRange();
-  if (range.IsNull())
+  if (range.IsNull()) {
     return 0;
+  }
 
   return range.StartOffset();
 }
 
 int CefDOMDocumentImpl::GetSelectionEndOffset() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return 0;
+  }
 
-  if (!frame_->HasSelection())
+  if (!frame_->HasSelection()) {
     return 0;
+  }
 
   const WebRange& range = frame_->SelectionRange();
-  if (range.IsNull())
+  if (range.IsNull()) {
     return 0;
+  }
 
   return range.EndOffset();
 }
 
 CefString CefDOMDocumentImpl::GetSelectionAsMarkup() {
   CefString str;
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return str;
+  }
 
-  if (!frame_->HasSelection())
+  if (!frame_->HasSelection()) {
     return str;
+  }
 
   const WebString& markup = frame_->SelectionAsMarkup();
-  if (!markup.IsNull())
+  if (!markup.IsNull()) {
     str = markup.Utf16();
+  }
 
   return str;
 }
 
 CefString CefDOMDocumentImpl::GetSelectionAsText() {
   CefString str;
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return str;
+  }
 
-  if (!frame_->HasSelection())
+  if (!frame_->HasSelection()) {
     return str;
+  }
 
   const WebString& text = frame_->SelectionAsText();
-  if (!text.IsNull())
+  if (!text.IsNull()) {
     str = text.Utf16();
+  }
 
   return str;
 }
 
 CefString CefDOMDocumentImpl::GetBaseURL() {
   CefString str;
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return str;
+  }
 
   const WebDocument& document = frame_->GetDocument();
   const WebURL& url = document.BaseURL();
@@ -172,8 +192,9 @@ CefString CefDOMDocumentImpl::GetBaseURL() {
 
 CefString CefDOMDocumentImpl::GetCompleteURL(const CefString& partialURL) {
   CefString str;
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return str;
+  }
 
   const WebDocument& document = frame_->GetDocument();
   const WebURL& url =
@@ -188,18 +209,21 @@ CefString CefDOMDocumentImpl::GetCompleteURL(const CefString& partialURL) {
 
 CefRefPtr<CefDOMNode> CefDOMDocumentImpl::GetOrCreateNode(
     const blink::WebNode& node) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return nullptr;
+  }
 
   // Nodes may potentially be null.
-  if (node.IsNull())
+  if (node.IsNull()) {
     return nullptr;
+  }
 
   if (!node_map_.empty()) {
     // Locate the existing node, if any.
     NodeMap::const_iterator it = node_map_.find(node);
-    if (it != node_map_.end())
+    if (it != node_map_.end()) {
       return it->second;
+    }
   }
 
   // Create the new node object.
@@ -209,19 +233,22 @@ CefRefPtr<CefDOMNode> CefDOMDocumentImpl::GetOrCreateNode(
 }
 
 void CefDOMDocumentImpl::RemoveNode(const blink::WebNode& node) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return;
+  }
 
   if (!node_map_.empty()) {
     NodeMap::iterator it = node_map_.find(node);
-    if (it != node_map_.end())
+    if (it != node_map_.end()) {
       node_map_.erase(it);
+    }
   }
 }
 
 void CefDOMDocumentImpl::Detach() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return;
+  }
 
   // If you hit this assert it means that you are keeping references to node
   // objects beyond the valid scope.
@@ -233,8 +260,9 @@ void CefDOMDocumentImpl::Detach() {
 
   if (!node_map_.empty()) {
     NodeMap::const_iterator it = node_map_.begin();
-    for (; it != node_map_.end(); ++it)
+    for (; it != node_map_.end(); ++it) {
       static_cast<CefDOMNodeImpl*>(it->second)->Detach();
+    }
     node_map_.clear();
   }
 
diff --git a/libcef/renderer/dom_node_impl.cc b/libcef/renderer/dom_node_impl.cc
index 06dc995c2..8ae90c084 100644
--- a/libcef/renderer/dom_node_impl.cc
+++ b/libcef/renderer/dom_node_impl.cc
@@ -45,38 +45,44 @@ CefDOMNodeImpl::~CefDOMNodeImpl() {
 }
 
 CefDOMNodeImpl::Type CefDOMNodeImpl::GetType() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return DOM_NODE_TYPE_UNSUPPORTED;
+  }
 
   return blink_glue::GetNodeType(node_);
 }
 
 bool CefDOMNodeImpl::IsText() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   return node_.IsTextNode();
 }
 
 bool CefDOMNodeImpl::IsElement() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   return node_.IsElementNode();
 }
 
 // Logic copied from RenderViewImpl::IsEditableNode.
 bool CefDOMNodeImpl::IsEditable() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
-  if (node_.IsContentEditable())
+  if (node_.IsContentEditable()) {
     return true;
+  }
 
   if (node_.IsElementNode()) {
     const WebElement& element = node_.To<WebElement>();
-    if (blink_glue::IsTextControlElement(element))
+    if (blink_glue::IsTextControlElement(element)) {
       return true;
+    }
 
     // Also return true if it has an ARIA role of 'textbox'.
     for (unsigned i = 0; i < element.AttributeCount(); ++i) {
@@ -95,8 +101,9 @@ bool CefDOMNodeImpl::IsEditable() {
 }
 
 bool CefDOMNodeImpl::IsFormControlElement() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   if (node_.IsElementNode()) {
     const WebElement& element = node_.To<WebElement>();
@@ -108,8 +115,9 @@ bool CefDOMNodeImpl::IsFormControlElement() {
 
 CefString CefDOMNodeImpl::GetFormControlElementType() {
   CefString str;
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return str;
+  }
 
   if (node_.IsElementNode()) {
     const WebElement& element = node_.To<WebElement>();
@@ -128,32 +136,37 @@ CefString CefDOMNodeImpl::GetFormControlElementType() {
 }
 
 bool CefDOMNodeImpl::IsSame(CefRefPtr<CefDOMNode> that) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   CefDOMNodeImpl* impl = static_cast<CefDOMNodeImpl*>(that.get());
-  if (!impl || !impl->VerifyContext())
+  if (!impl || !impl->VerifyContext()) {
     return false;
+  }
 
   return node_.Equals(impl->node_);
 }
 
 CefString CefDOMNodeImpl::GetName() {
   CefString str;
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return str;
+  }
 
   const WebString& name = blink_glue::GetNodeName(node_);
-  if (!name.IsNull())
+  if (!name.IsNull()) {
     str = name.Utf16();
+  }
 
   return str;
 }
 
 CefString CefDOMNodeImpl::GetValue() {
   CefString str;
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return str;
+  }
 
   if (node_.IsElementNode()) {
     const WebElement& element = node_.To<WebElement>();
@@ -182,19 +195,22 @@ CefString CefDOMNodeImpl::GetValue() {
 
   if (str.empty()) {
     const WebString& value = node_.NodeValue();
-    if (!value.IsNull())
+    if (!value.IsNull()) {
       str = value.Utf16();
+    }
   }
 
   return str;
 }
 
 bool CefDOMNodeImpl::SetValue(const CefString& value) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
-  if (node_.IsElementNode())
+  if (node_.IsElementNode()) {
     return false;
+  }
 
   return blink_glue::SetNodeValue(node_,
                                   WebString::FromUTF16(value.ToString16()));
@@ -202,69 +218,79 @@ bool CefDOMNodeImpl::SetValue(const CefString& value) {
 
 CefString CefDOMNodeImpl::GetAsMarkup() {
   CefString str;
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return str;
+  }
 
   const WebString& markup = blink_glue::CreateNodeMarkup(node_);
-  if (!markup.IsNull())
+  if (!markup.IsNull()) {
     str = markup.Utf16();
+  }
 
   return str;
 }
 
 CefRefPtr<CefDOMDocument> CefDOMNodeImpl::GetDocument() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return nullptr;
+  }
 
   return document_.get();
 }
 
 CefRefPtr<CefDOMNode> CefDOMNodeImpl::GetParent() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return nullptr;
+  }
 
   return document_->GetOrCreateNode(node_.ParentNode());
 }
 
 CefRefPtr<CefDOMNode> CefDOMNodeImpl::GetPreviousSibling() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return nullptr;
+  }
 
   return document_->GetOrCreateNode(node_.PreviousSibling());
 }
 
 CefRefPtr<CefDOMNode> CefDOMNodeImpl::GetNextSibling() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return nullptr;
+  }
 
   return document_->GetOrCreateNode(node_.NextSibling());
 }
 
 bool CefDOMNodeImpl::HasChildren() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   return !node_.FirstChild().IsNull();
 }
 
 CefRefPtr<CefDOMNode> CefDOMNodeImpl::GetFirstChild() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return nullptr;
+  }
 
   return document_->GetOrCreateNode(node_.FirstChild());
 }
 
 CefRefPtr<CefDOMNode> CefDOMNodeImpl::GetLastChild() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return nullptr;
+  }
 
   return document_->GetOrCreateNode(node_.LastChild());
 }
 
 CefString CefDOMNodeImpl::GetElementTagName() {
   CefString str;
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return str;
+  }
 
   if (!node_.IsElementNode()) {
     NOTREACHED();
@@ -273,15 +299,17 @@ CefString CefDOMNodeImpl::GetElementTagName() {
 
   const WebElement& element = node_.To<blink::WebElement>();
   const WebString& tagname = element.TagName();
-  if (!tagname.IsNull())
+  if (!tagname.IsNull()) {
     str = tagname.Utf16();
+  }
 
   return str;
 }
 
 bool CefDOMNodeImpl::HasElementAttributes() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   if (!node_.IsElementNode()) {
     NOTREACHED();
@@ -293,8 +321,9 @@ bool CefDOMNodeImpl::HasElementAttributes() {
 }
 
 bool CefDOMNodeImpl::HasElementAttribute(const CefString& attrName) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   if (!node_.IsElementNode()) {
     NOTREACHED();
@@ -307,8 +336,9 @@ bool CefDOMNodeImpl::HasElementAttribute(const CefString& attrName) {
 
 CefString CefDOMNodeImpl::GetElementAttribute(const CefString& attrName) {
   CefString str;
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return str;
+  }
 
   if (!node_.IsElementNode()) {
     NOTREACHED();
@@ -318,15 +348,17 @@ CefString CefDOMNodeImpl::GetElementAttribute(const CefString& attrName) {
   const WebElement& element = node_.To<blink::WebElement>();
   const WebString& attr =
       element.GetAttribute(WebString::FromUTF16(attrName.ToString16()));
-  if (!attr.IsNull())
+  if (!attr.IsNull()) {
     str = attr.Utf16();
+  }
 
   return str;
 }
 
 void CefDOMNodeImpl::GetElementAttributes(AttributeMap& attrMap) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return;
+  }
 
   if (!node_.IsElementNode()) {
     NOTREACHED();
@@ -335,8 +367,9 @@ void CefDOMNodeImpl::GetElementAttributes(AttributeMap& attrMap) {
 
   const WebElement& element = node_.To<blink::WebElement>();
   unsigned int len = element.AttributeCount();
-  if (len == 0)
+  if (len == 0) {
     return;
+  }
 
   for (unsigned int i = 0; i < len; ++i) {
     std::u16string name = element.AttributeLocalName(i).Utf16();
@@ -347,8 +380,9 @@ void CefDOMNodeImpl::GetElementAttributes(AttributeMap& attrMap) {
 
 bool CefDOMNodeImpl::SetElementAttribute(const CefString& attrName,
                                          const CefString& value) {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
 
   if (!node_.IsElementNode()) {
     NOTREACHED();
@@ -363,8 +397,9 @@ bool CefDOMNodeImpl::SetElementAttribute(const CefString& attrName,
 
 CefString CefDOMNodeImpl::GetElementInnerText() {
   CefString str;
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return str;
+  }
 
   if (!node_.IsElementNode()) {
     NOTREACHED();
@@ -373,16 +408,18 @@ CefString CefDOMNodeImpl::GetElementInnerText() {
 
   WebElement element = node_.To<blink::WebElement>();
   const WebString& text = element.TextContent();
-  if (!text.IsNull())
+  if (!text.IsNull()) {
     str = text.Utf16();
+  }
 
   return str;
 }
 
 CefRect CefDOMNodeImpl::GetElementBounds() {
   CefRect rect;
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return rect;
+  }
 
   if (!node_.IsElementNode()) {
     NOTREACHED();
@@ -406,8 +443,9 @@ bool CefDOMNodeImpl::VerifyContext() {
     NOTREACHED();
     return false;
   }
-  if (!document_->VerifyContext())
+  if (!document_->VerifyContext()) {
     return false;
+  }
   if (node_.IsNull()) {
     NOTREACHED();
     return false;
diff --git a/libcef/renderer/extensions/extensions_renderer_client.cc b/libcef/renderer/extensions/extensions_renderer_client.cc
index 8f25c8d9f..a571d42df 100644
--- a/libcef/renderer/extensions/extensions_renderer_client.cc
+++ b/libcef/renderer/extensions/extensions_renderer_client.cc
@@ -100,8 +100,9 @@ void CefExtensionsRendererClient::RenderFrameCreated(
 bool CefExtensionsRendererClient::OverrideCreatePlugin(
     content::RenderFrame* render_frame,
     const blink::WebPluginParams& params) {
-  if (params.mime_type.Utf8() != content::kBrowserPluginMimeType)
+  if (params.mime_type.Utf8() != content::kBrowserPluginMimeType) {
     return true;
+  }
 
   bool guest_view_api_available = false;
   extension_dispatcher_->script_context_set_iterator()->ForEach(
diff --git a/libcef/renderer/frame_impl.cc b/libcef/renderer/frame_impl.cc
index bfa1a880e..ae59dc13a 100644
--- a/libcef/renderer/frame_impl.cc
+++ b/libcef/renderer/frame_impl.cc
@@ -131,8 +131,9 @@ void CefFrameImpl::GetText(CefRefPtr<CefStringVisitor> visitor) {
 void CefFrameImpl::LoadRequest(CefRefPtr<CefRequest> request) {
   CEF_REQUIRE_RT_RETURN_VOID();
 
-  if (!frame_)
+  if (!frame_) {
     return;
+  }
 
   auto params = cef::mojom::RequestParams::New();
   static_cast<CefRequestImpl*>(request.get())->Get(params);
@@ -142,8 +143,9 @@ void CefFrameImpl::LoadRequest(CefRefPtr<CefRequest> request) {
 void CefFrameImpl::LoadURL(const CefString& url) {
   CEF_REQUIRE_RT_RETURN_VOID();
 
-  if (!frame_)
+  if (!frame_) {
     return;
+  }
 
   auto params = cef::mojom::RequestParams::New();
   params->url = GURL(url.ToString());
@@ -160,16 +162,18 @@ void CefFrameImpl::ExecuteJavaScript(const CefString& jsCode,
 bool CefFrameImpl::IsMain() {
   CEF_REQUIRE_RT_RETURN(false);
 
-  if (frame_)
+  if (frame_) {
     return (frame_->Parent() == nullptr);
+  }
   return false;
 }
 
 bool CefFrameImpl::IsFocused() {
   CEF_REQUIRE_RT_RETURN(false);
 
-  if (frame_ && frame_->View())
+  if (frame_ && frame_->View()) {
     return (frame_->View()->FocusedFrame() == frame_);
+  }
   return false;
 }
 
@@ -177,8 +181,9 @@ CefString CefFrameImpl::GetName() {
   CefString name;
   CEF_REQUIRE_RT_RETURN(name);
 
-  if (frame_)
+  if (frame_) {
     name = render_frame_util::GetName(frame_);
+  }
   return name;
 }
 
@@ -193,8 +198,9 @@ CefRefPtr<CefFrame> CefFrameImpl::GetParent() {
 
   if (frame_) {
     blink::WebFrame* parent = frame_->Parent();
-    if (parent && parent->IsWebLocalFrame())
+    if (parent && parent->IsWebLocalFrame()) {
       return browser_->GetWebFrameImpl(parent->ToWebLocalFrame()).get();
+    }
   }
 
   return nullptr;
@@ -232,20 +238,23 @@ CefRefPtr<CefV8Context> CefFrameImpl::GetV8Context() {
 void CefFrameImpl::VisitDOM(CefRefPtr<CefDOMVisitor> visitor) {
   CEF_REQUIRE_RT_RETURN_VOID();
 
-  if (!frame_)
+  if (!frame_) {
     return;
+  }
 
   // Create a CefDOMDocumentImpl object that is valid only for the scope of this
   // method.
   CefRefPtr<CefDOMDocumentImpl> documentImpl;
   const blink::WebDocument& document = frame_->GetDocument();
-  if (!document.IsNull())
+  if (!document.IsNull()) {
     documentImpl = new CefDOMDocumentImpl(browser_, frame_);
+  }
 
   visitor->Visit(documentImpl.get());
 
-  if (documentImpl.get())
+  if (documentImpl.get()) {
     documentImpl->Detach();
+  }
 }
 
 CefRefPtr<CefURLRequest> CefFrameImpl::CreateURLRequest(
@@ -253,13 +262,15 @@ CefRefPtr<CefURLRequest> CefFrameImpl::CreateURLRequest(
     CefRefPtr<CefURLRequestClient> client) {
   CEF_REQUIRE_RT_RETURN(nullptr);
 
-  if (!request || !client || !frame_)
+  if (!request || !client || !frame_) {
     return nullptr;
+  }
 
   CefRefPtr<CefRenderURLRequest> impl =
       new CefRenderURLRequest(this, request, client);
-  if (impl->Start())
+  if (impl->Start()) {
     return impl.get();
+  }
   return nullptr;
 }
 
@@ -268,8 +279,9 @@ void CefFrameImpl::SendProcessMessage(CefProcessId target_process,
   CEF_REQUIRE_RT_RETURN_VOID();
   DCHECK_EQ(PID_BROWSER, target_process);
   DCHECK(message && message->IsValid());
-  if (!message || !message->IsValid())
+  if (!message || !message->IsValid()) {
     return;
+  }
 
   if (message->GetArgumentList() != nullptr) {
     // Invalidate the message object immediately by taking the argument list.
@@ -299,8 +311,9 @@ void CefFrameImpl::SendProcessMessage(CefProcessId target_process,
 
 std::unique_ptr<blink::WebURLLoader> CefFrameImpl::CreateURLLoader() {
   CEF_REQUIRE_RT();
-  if (!frame_)
+  if (!frame_) {
     return nullptr;
+  }
 
   if (!url_loader_factory_) {
     auto render_frame = content::RenderFrameImpl::FromWebFrame(frame_);
@@ -308,8 +321,9 @@ std::unique_ptr<blink::WebURLLoader> CefFrameImpl::CreateURLLoader() {
       url_loader_factory_ = render_frame->CreateURLLoaderFactory();
     }
   }
-  if (!url_loader_factory_)
+  if (!url_loader_factory_) {
     return nullptr;
+  }
 
   return url_loader_factory_->CreateURLLoader(
       blink::WebURLRequest(),
@@ -324,8 +338,9 @@ CefFrameImpl::CreateResourceLoadInfoNotifierWrapper() {
   CEF_REQUIRE_RT();
   if (frame_) {
     auto render_frame = content::RenderFrameImpl::FromWebFrame(frame_);
-    if (render_frame)
+    if (render_frame) {
       return render_frame->CreateResourceLoadInfoNotifierWrapper();
+    }
   }
   return nullptr;
 }
@@ -350,8 +365,9 @@ void CefFrameImpl::OnDidCommitProvisionalLoad() {
 void CefFrameImpl::OnDidFinishLoad() {
   // Ignore notifications from the embedded frame hosting a mime-type plugin.
   // We'll eventually receive a notification from the owner frame.
-  if (blink_glue::HasPluginFrameOwner(frame_))
+  if (blink_glue::HasPluginFrameOwner(frame_)) {
     return;
+  }
 
   if (!blink::RuntimeEnabledFeatures::BackForwardCacheEnabled() && IsMain()) {
     // Refresh draggable regions. Otherwise, we may not receive updated regions
@@ -380,8 +396,9 @@ void CefFrameImpl::OnDraggableRegionsChanged() {
   // Match the behavior in ChromeRenderFrameObserver::DraggableRegionsChanged.
   // Only the main frame is allowed to control draggable regions, to avoid other
   // frames manipulate the regions in the browser process.
-  if (frame_->Parent() != nullptr)
+  if (frame_->Parent() != nullptr) {
     return;
+  }
 
   blink::WebVector<blink::WebDraggableRegion> webregions =
       frame_->GetDocument().DraggableRegions();
@@ -606,8 +623,9 @@ void CefFrameImpl::OnDisconnect(DisconnectReason reason) {
         break;
     }
 
-    if (!frame_)
+    if (!frame_) {
       state_str += ", FRAME_INVALID";
+    }
 
     VLOG(1) << GetDebugString() << " disconnected (reason=" << reason_str
             << ", current_state=" << state_str << ")";
diff --git a/libcef/renderer/render_frame_observer.cc b/libcef/renderer/render_frame_observer.cc
index d4fd36f18..45d59df07 100644
--- a/libcef/renderer/render_frame_observer.cc
+++ b/libcef/renderer/render_frame_observer.cc
@@ -38,8 +38,9 @@ CefRenderFrameObserver::~CefRenderFrameObserver() = default;
 
 void CefRenderFrameObserver::DidCommitProvisionalLoad(
     ui::PageTransition transition) {
-  if (!frame_)
+  if (!frame_) {
     return;
+  }
 
   frame_->OnDidCommitProvisionalLoad();
 
@@ -79,21 +80,25 @@ void CefRenderFrameObserver::WillDetach() {
 
 void CefRenderFrameObserver::FocusedElementChanged(
     const blink::WebElement& element) {
-  if (!frame_)
+  if (!frame_) {
     return;
+  }
 
   blink::WebLocalFrame* frame = render_frame()->GetWebFrame();
   CefRefPtr<CefBrowserImpl> browserPtr =
       CefBrowserImpl::GetBrowserForMainFrame(frame->Top());
-  if (!browserPtr)
+  if (!browserPtr) {
     return;
+  }
 
   CefRefPtr<CefRenderProcessHandler> handler;
   CefRefPtr<CefApp> application = CefAppManager::Get()->GetApplication();
-  if (application)
+  if (application) {
     handler = application->GetRenderProcessHandler();
-  if (!handler)
+  }
+  if (!handler) {
     return;
+  }
 
   CefRefPtr<CefFrameImpl> framePtr = browserPtr->GetWebFrameImpl(frame);
 
@@ -102,8 +107,9 @@ void CefRenderFrameObserver::FocusedElementChanged(
     return;
   }
 
-  if (element.GetDocument().IsNull())
+  if (element.GetDocument().IsNull()) {
     return;
+  }
 
   CefRefPtr<CefDOMDocumentImpl> documentImpl =
       new CefDOMDocumentImpl(browserPtr.get(), frame);
@@ -121,19 +127,22 @@ void CefRenderFrameObserver::DraggableRegionsChanged() {
 void CefRenderFrameObserver::DidCreateScriptContext(
     v8::Handle<v8::Context> context,
     int world_id) {
-  if (!frame_)
+  if (!frame_) {
     return;
+  }
 
   blink::WebLocalFrame* frame = render_frame()->GetWebFrame();
   CefRefPtr<CefBrowserImpl> browserPtr =
       CefBrowserImpl::GetBrowserForMainFrame(frame->Top());
-  if (!browserPtr)
+  if (!browserPtr) {
     return;
+  }
 
   CefRefPtr<CefRenderProcessHandler> handler;
   CefRefPtr<CefApp> application = CefAppManager::Get()->GetApplication();
-  if (application)
+  if (application) {
     handler = application->GetRenderProcessHandler();
+  }
 
   CefRefPtr<CefFrameImpl> framePtr = browserPtr->GetWebFrameImpl(frame);
 
@@ -159,13 +168,15 @@ void CefRenderFrameObserver::WillReleaseScriptContext(
   blink::WebLocalFrame* frame = render_frame()->GetWebFrame();
   CefRefPtr<CefBrowserImpl> browserPtr =
       CefBrowserImpl::GetBrowserForMainFrame(frame->Top());
-  if (!browserPtr)
+  if (!browserPtr) {
     return;
+  }
 
   CefRefPtr<CefRenderProcessHandler> handler;
   CefRefPtr<CefApp> application = CefAppManager::Get()->GetApplication();
-  if (application)
+  if (application) {
     handler = application->GetRenderProcessHandler();
+  }
 
   CefRefPtr<CefFrameImpl> framePtr = browserPtr->GetWebFrameImpl(frame);
 
diff --git a/libcef/renderer/render_frame_util.cc b/libcef/renderer/render_frame_util.cc
index a87aec83b..62d954969 100644
--- a/libcef/renderer/render_frame_util.cc
+++ b/libcef/renderer/render_frame_util.cc
@@ -36,8 +36,9 @@ std::string GetName(blink::WebLocalFrame* frame) {
   content::RenderFrameImpl* render_frame =
       content::RenderFrameImpl::FromWebFrame(frame);
   DCHECK(render_frame);
-  if (render_frame)
+  if (render_frame) {
     return render_frame->unique_name();
+  }
   return std::string();
 }
 
diff --git a/libcef/renderer/render_manager.cc b/libcef/renderer/render_manager.cc
index 2f04953fb..85a9cbb50 100644
--- a/libcef/renderer/render_manager.cc
+++ b/libcef/renderer/render_manager.cc
@@ -155,8 +155,9 @@ void CefRenderManager::ExposeInterfacesToBrowser(mojo::BinderMap* binders) {
 CefRefPtr<CefBrowserImpl> CefRenderManager::GetBrowserForView(
     blink::WebView* view) {
   BrowserMap::const_iterator it = browsers_.find(view);
-  if (it != browsers_.end())
+  if (it != browsers_.end()) {
     return it->second;
+  }
   return nullptr;
 }
 
@@ -239,10 +240,12 @@ void CefRenderManager::WebKitInitialized() {
       const CefSchemeInfo& info = *it;
       const blink::WebString& scheme =
           blink::WebString::FromUTF8(info.scheme_name);
-      if (info.is_display_isolated)
+      if (info.is_display_isolated) {
         blink::WebSecurityPolicy::RegisterURLSchemeAsDisplayIsolated(scheme);
-      if (info.is_fetch_enabled)
+      }
+      if (info.is_fetch_enabled) {
         blink_glue::RegisterURLSchemeAsSupportingFetchAPI(scheme);
+      }
     }
   }
 
@@ -272,8 +275,9 @@ void CefRenderManager::WebKitInitialized() {
   if (application.get()) {
     CefRefPtr<CefRenderProcessHandler> handler =
         application->GetRenderProcessHandler();
-    if (handler.get())
+    if (handler.get()) {
       handler->OnWebKitInitialized();
+    }
   }
 }
 
@@ -282,11 +286,13 @@ CefRefPtr<CefBrowserImpl> CefRenderManager::MaybeCreateBrowser(
     content::RenderFrame* render_frame,
     bool* browser_created,
     absl::optional<bool>* is_windowless) {
-  if (browser_created)
+  if (browser_created) {
     *browser_created = false;
+  }
 
-  if (!web_view || !render_frame)
+  if (!web_view || !render_frame) {
     return nullptr;
+  }
 
   // Don't create another browser or guest view object if one already exists for
   // the view.
@@ -350,13 +356,15 @@ CefRefPtr<CefBrowserImpl> CefRenderManager::MaybeCreateBrowser(
             /*will_delete=*/false, /*read_only=*/true);
       }
       handler->OnBrowserCreated(browser.get(), dictValuePtr.get());
-      if (dictValuePtr)
+      if (dictValuePtr) {
         std::ignore = dictValuePtr->Detach(nullptr);
+      }
     }
   }
 
-  if (browser_created)
+  if (browser_created) {
     *browser_created = true;
+  }
 
   return browser;
 }
@@ -378,8 +386,9 @@ CefGuestView* CefRenderManager::GetGuestViewForView(blink::WebView* view) {
   CEF_REQUIRE_RT_RETURN(nullptr);
 
   GuestViewMap::const_iterator it = guest_views_.find(view);
-  if (it != guest_views_.end())
+  if (it != guest_views_.end()) {
     return it->second.get();
+  }
   return nullptr;
 }
 
diff --git a/libcef/renderer/render_urlrequest_impl.cc b/libcef/renderer/render_urlrequest_impl.cc
index 668d19252..b26af0725 100644
--- a/libcef/renderer/render_urlrequest_impl.cc
+++ b/libcef/renderer/render_urlrequest_impl.cc
@@ -106,8 +106,9 @@ class CefRenderURLRequest::Context
 
   bool Start() {
     GURL url = GURL(request_->GetURL().ToString());
-    if (!url.is_valid())
+    if (!url.is_valid()) {
       return false;
+    }
 
     url_client_.reset(new CefWebURLLoaderClient(this, request_->GetFlags()));
 
@@ -157,8 +158,9 @@ class CefRenderURLRequest::Context
 
   void Cancel() {
     // The request may already be complete.
-    if (!loader_.get() || status_ != UR_IO_PENDING)
+    if (!loader_.get() || status_ != UR_IO_PENDING) {
       return;
+    }
 
     status_ = UR_CANCELED;
     error_code_ = ERR_ABORTED;
@@ -217,8 +219,9 @@ class CefRenderURLRequest::Context
       NotifyUploadProgressIfNecessary();
     }
 
-    if (loader_.get())
+    if (loader_.get()) {
       loader_.reset(nullptr);
+    }
 
     DCHECK(url_request_.get());
     client_->OnRequestComplete(url_request_.get());
@@ -298,8 +301,9 @@ class CefRenderURLRequest::Context
 
   void OnUploadProgress(int64_t current, int64_t total) {
     DCHECK(url_request_.get());
-    if (current == total)
+    if (current == total) {
       got_upload_progress_complete_ = true;
+    }
     client_->OnUploadProgress(url_request_.get(), current, total);
   }
 
@@ -357,8 +361,9 @@ CefWebURLLoaderClient::~CefWebURLLoaderClient() {}
 
 void CefWebURLLoaderClient::DidSendData(uint64_t bytes_sent,
                                         uint64_t total_bytes_to_be_sent) {
-  if (request_flags_ & UR_FLAG_REPORT_UPLOAD_PROGRESS)
+  if (request_flags_ & UR_FLAG_REPORT_UPLOAD_PROGRESS) {
     context_->OnUploadProgress(bytes_sent, total_bytes_to_be_sent);
+  }
 }
 
 void CefWebURLLoaderClient::DidReceiveResponse(const WebURLResponse& response) {
@@ -368,8 +373,9 @@ void CefWebURLLoaderClient::DidReceiveResponse(const WebURLResponse& response) {
 void CefWebURLLoaderClient::DidReceiveData(const char* data, int dataLength) {
   context_->OnDownloadProgress(dataLength);
 
-  if (!(request_flags_ & UR_FLAG_NO_DOWNLOAD_DATA))
+  if (!(request_flags_ & UR_FLAG_NO_DOWNLOAD_DATA)) {
     context_->OnDownloadData(data, dataLength);
+  }
 }
 
 void CefWebURLLoaderClient::DidFinishLoading(
@@ -429,50 +435,58 @@ CefRenderURLRequest::CefRenderURLRequest(
 CefRenderURLRequest::~CefRenderURLRequest() {}
 
 bool CefRenderURLRequest::Start() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
   return context_->Start();
 }
 
 CefRefPtr<CefRequest> CefRenderURLRequest::GetRequest() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return nullptr;
+  }
   return context_->request();
 }
 
 CefRefPtr<CefURLRequestClient> CefRenderURLRequest::GetClient() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return nullptr;
+  }
   return context_->client();
 }
 
 CefURLRequest::Status CefRenderURLRequest::GetRequestStatus() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return UR_UNKNOWN;
+  }
   return context_->status();
 }
 
 CefURLRequest::ErrorCode CefRenderURLRequest::GetRequestError() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return ERR_NONE;
+  }
   return context_->error_code();
 }
 
 CefRefPtr<CefResponse> CefRenderURLRequest::GetResponse() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return nullptr;
+  }
   return context_->response();
 }
 
 bool CefRenderURLRequest::ResponseWasCached() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return false;
+  }
   return context_->response_was_cached();
 }
 
 void CefRenderURLRequest::Cancel() {
-  if (!VerifyContext())
+  if (!VerifyContext()) {
     return;
+  }
   return context_->Cancel();
 }
 
diff --git a/libcef/renderer/v8_impl.cc b/libcef/renderer/v8_impl.cc
index e91a9133f..26c3d0cb4 100644
--- a/libcef/renderer/v8_impl.cc
+++ b/libcef/renderer/v8_impl.cc
@@ -105,16 +105,18 @@ class CefV8IsolateManager {
     DCHECK(context.IsEmpty() || isolate_ == context->GetIsolate());
 
     if (context.IsEmpty()) {
-      if (isolate_->InContext())
+      if (isolate_->InContext()) {
         context = isolate_->GetCurrentContext();
-      else
+      } else {
         return scoped_refptr<CefV8ContextState>();
+      }
     }
 
     int hash = context->Global()->GetIdentityHash();
     ContextMap::const_iterator it = context_map_.find(hash);
-    if (it != context_map_.end())
+    if (it != context_map_.end()) {
       return it->second;
+    }
 
     scoped_refptr<CefV8ContextState> state = new CefV8ContextState();
     context_map_.insert(std::make_pair(hash, state));
@@ -145,8 +147,9 @@ class CefV8IsolateManager {
   }
 
   void SetUncaughtExceptionStackSize(int stack_size) {
-    if (stack_size <= 0)
+    if (stack_size <= 0) {
       return;
+    }
 
     if (!message_listener_registered_) {
       isolate_->AddMessageListener(&MessageListenerCallbackImpl);
@@ -250,8 +253,9 @@ class V8TrackObject : public CefTrackNode {
       new_value = 0;
     }
 
-    if (change_in_bytes != 0)
+    if (change_in_bytes != 0) {
       isolate_->AdjustAmountOfExternalAllocatedMemory(change_in_bytes);
+    }
     external_memory_ = new_value;
 
     return new_value;
@@ -291,8 +295,9 @@ class V8TrackObject : public CefTrackNode {
   static V8TrackObject* Unwrap(v8::Local<v8::Context> context,
                                v8::Local<v8::Object> object) {
     v8::Local<v8::Value> value;
-    if (GetPrivate(context, object, kCefTrackObject, &value))
+    if (GetPrivate(context, object, kCefTrackObject, &value)) {
       return static_cast<V8TrackObject*>(v8::External::Cast(*value)->Value());
+    }
 
     return nullptr;
   }
@@ -346,9 +351,10 @@ class V8TrackArrayBuffer : public CefTrackNode {
   static V8TrackArrayBuffer* Unwrap(v8::Local<v8::Context> context,
                                     v8::Local<v8::Object> object) {
     v8::Local<v8::Value> value;
-    if (GetPrivate(context, object, kCefTrackObject, &value))
+    if (GetPrivate(context, object, kCefTrackObject, &value)) {
       return static_cast<V8TrackArrayBuffer*>(
           v8::External::Cast(*value)->Value());
+    }
 
     return nullptr;
   }
@@ -378,8 +384,9 @@ class V8FunctionData {
   CefString function_name() const { return function_name_; }
 
   CefV8Handler* handler() const {
-    if (!handler_)
+    if (!handler_) {
       return nullptr;
+    }
     return handler_.get();
   }
 
@@ -468,14 +475,16 @@ void v8impl_string_dtor(char* str) {
 void GetCefString(v8::Isolate* isolate,
                   v8::Local<v8::String> str,
                   CefString& out) {
-  if (str.IsEmpty())
+  if (str.IsEmpty()) {
     return;
+  }
 
 #if defined(CEF_STRING_TYPE_WIDE)
   // Allocate enough space for a worst-case conversion.
   int len = str->Utf8Length();
-  if (len == 0)
+  if (len == 0) {
     return;
+  }
   char* buf = new char[len + 1];
   str->WriteUtf8(isolate, buf, len + 1);
 
@@ -487,15 +496,17 @@ void GetCefString(v8::Isolate* isolate,
 #else  // !defined(CEF_STRING_TYPE_WIDE)
 #if defined(CEF_STRING_TYPE_UTF16)
   int len = str->Length();
-  if (len == 0)
+  if (len == 0) {
     return;
+  }
   char16* buf = new char16[len + 1];
   str->Write(isolate, reinterpret_cast<uint16_t*>(buf), 0, len + 1);
 #else
   // Allocate enough space for a worst-case conversion.
   int len = str->Utf8Length();
-  if (len == 0)
+  if (len == 0) {
     return;
+  }
   char* buf = new char[len + 1];
   str->WriteUtf8(isolate, buf, len + 1);
 #endif
@@ -521,8 +532,9 @@ void FunctionCallbackImpl(const v8::FunctionCallbackInfo<v8::Value>& info) {
     return;
   }
   CefV8ValueList params;
-  for (int i = 0; i < info.Length(); i++)
+  for (int i = 0; i < info.Length(); i++) {
     params.push_back(new CefV8ValueImpl(isolate, context, info[i]));
+  }
 
   CefRefPtr<CefV8Value> object =
       new CefV8ValueImpl(isolate, context, info.This());
@@ -559,8 +571,9 @@ void AccessorNameGetterCallbackImpl(
   CefRefPtr<CefV8Accessor> accessorPtr;
 
   V8TrackObject* tracker = V8TrackObject::Unwrap(context, obj);
-  if (tracker)
+  if (tracker) {
     accessorPtr = tracker->GetAccessor();
+  }
 
   if (accessorPtr.get()) {
     CefRefPtr<CefV8Value> retval;
@@ -597,8 +610,9 @@ void AccessorNameSetterCallbackImpl(
   CefRefPtr<CefV8Accessor> accessorPtr;
 
   V8TrackObject* tracker = V8TrackObject::Unwrap(context, obj);
-  if (tracker)
+  if (tracker) {
     accessorPtr = tracker->GetAccessor();
+  }
 
   if (accessorPtr.get()) {
     CefRefPtr<CefV8Value> object = new CefV8ValueImpl(isolate, context, obj);
@@ -640,10 +654,12 @@ void InterceptorGetterCallbackImpl(
   CefRefPtr<CefV8Interceptor> interceptorPtr;
 
   V8TrackObject* tracker = V8TrackObject::Unwrap(context, obj);
-  if (tracker)
+  if (tracker) {
     interceptorPtr = tracker->GetInterceptor();
-  if (!interceptorPtr.get())
+  }
+  if (!interceptorPtr.get()) {
     return;
+  }
 
   CefRefPtr<CefV8Value> object = new CefV8ValueImpl(isolate, context, obj);
   CefRefPtr<CefV8Value> retval;
@@ -672,11 +688,13 @@ void InterceptorSetterCallbackImpl(
   CefRefPtr<CefV8Interceptor> interceptorPtr;
 
   V8TrackObject* tracker = V8TrackObject::Unwrap(context, obj);
-  if (tracker)
+  if (tracker) {
     interceptorPtr = tracker->GetInterceptor();
+  }
 
-  if (!interceptorPtr.get())
+  if (!interceptorPtr.get()) {
     return;
+  }
   CefRefPtr<CefV8Value> object = new CefV8ValueImpl(isolate, context, obj);
   CefRefPtr<CefV8Value> cefValue = new CefV8ValueImpl(isolate, context, value);
   CefString exception;
@@ -700,8 +718,9 @@ class ExtensionWrapper : public v8::Extension {
   v8::Handle<v8::FunctionTemplate> GetNativeFunctionTemplate(
       v8::Isolate* isolate,
       v8::Handle<v8::String> name) override {
-    if (!handler_)
+    if (!handler_) {
       return v8::Local<v8::FunctionTemplate>();
+    }
 
     CefString func_name;
     GetCefString(isolate, name, func_name);
@@ -726,14 +745,16 @@ class CefV8ExceptionImpl : public CefV8Exception {
         end_position_(0),
         start_column_(0),
         end_column_(0) {
-    if (message.IsEmpty())
+    if (message.IsEmpty()) {
       return;
+    }
 
     v8::Isolate* isolate = context->GetIsolate();
     GetCefString(isolate, message->Get(), message_);
     v8::MaybeLocal<v8::String> source_line = message->GetSourceLine(context);
-    if (!source_line.IsEmpty())
+    if (!source_line.IsEmpty()) {
       GetCefString(isolate, source_line.ToLocalChecked(), source_line_);
+    }
 
     if (!message->GetScriptResourceName().IsEmpty()) {
       GetCefString(
@@ -743,8 +764,9 @@ class CefV8ExceptionImpl : public CefV8Exception {
     }
 
     v8::Maybe<int> line_number = message->GetLineNumber(context);
-    if (!line_number.IsNothing())
+    if (!line_number.IsNothing()) {
       line_number_ = line_number.ToChecked();
+    }
     start_position_ = message->GetStartPosition();
     end_position_ = message->GetEndPosition();
     start_column_ = message->GetStartColumn(context).FromJust();
@@ -776,13 +798,15 @@ class CefV8ExceptionImpl : public CefV8Exception {
 void MessageListenerCallbackImpl(v8::Handle<v8::Message> message,
                                  v8::Handle<v8::Value> data) {
   CefRefPtr<CefApp> application = CefAppManager::Get()->GetApplication();
-  if (!application.get())
+  if (!application.get()) {
     return;
+  }
 
   CefRefPtr<CefRenderProcessHandler> handler =
       application->GetRenderProcessHandler();
-  if (!handler.get())
+  if (!handler.get()) {
     return;
+  }
 
   v8::Isolate* isolate = GetIsolateManager()->isolate();
   CefRefPtr<CefV8Context> context = CefV8Context::GetCurrentContext();
@@ -968,8 +992,9 @@ CefRefPtr<CefBrowser> CefV8ContextImpl::GetBrowser() {
   CEF_V8_REQUIRE_VALID_HANDLE_RETURN(browser);
 
   blink::WebLocalFrame* webframe = GetWebFrame();
-  if (webframe)
+  if (webframe) {
     browser = CefBrowserImpl::GetBrowserForMainFrame(webframe->Top());
+  }
 
   return browser;
 }
@@ -993,8 +1018,9 @@ CefRefPtr<CefFrame> CefV8ContextImpl::GetFrame() {
 CefRefPtr<CefV8Value> CefV8ContextImpl::GetGlobal() {
   CEF_V8_REQUIRE_VALID_HANDLE_RETURN(nullptr);
 
-  if (blink_glue::IsScriptForbidden())
+  if (blink_glue::IsScriptForbidden()) {
     return nullptr;
+  }
 
   v8::Isolate* isolate = handle_->isolate();
   v8::HandleScope handle_scope(isolate);
@@ -1006,8 +1032,9 @@ CefRefPtr<CefV8Value> CefV8ContextImpl::GetGlobal() {
 bool CefV8ContextImpl::Enter() {
   CEF_V8_REQUIRE_VALID_HANDLE_RETURN(false);
 
-  if (blink_glue::IsScriptForbidden())
+  if (blink_glue::IsScriptForbidden()) {
     return false;
+  }
 
   v8::Isolate* isolate = handle_->isolate();
   v8::HandleScope handle_scope(isolate);
@@ -1027,8 +1054,9 @@ bool CefV8ContextImpl::Enter() {
 bool CefV8ContextImpl::Exit() {
   CEF_V8_REQUIRE_VALID_HANDLE_RETURN(false);
 
-  if (blink_glue::IsScriptForbidden())
+  if (blink_glue::IsScriptForbidden()) {
     return false;
+  }
 
   if (enter_count_ <= 0) {
     LOG(ERROR) << "Call to CefV8Context::Exit() without matching call to "
@@ -1052,8 +1080,9 @@ bool CefV8ContextImpl::IsSame(CefRefPtr<CefV8Context> that) {
   CEF_V8_REQUIRE_VALID_HANDLE_RETURN(false);
 
   CefV8ContextImpl* impl = static_cast<CefV8ContextImpl*>(that.get());
-  if (!impl || !impl->IsValid())
+  if (!impl || !impl->IsValid()) {
     return false;
+  }
 
   return (handle_->GetPersistentV8Handle() ==
           impl->handle_->GetPersistentV8Handle());
@@ -1069,8 +1098,9 @@ bool CefV8ContextImpl::Eval(const CefString& code,
 
   CEF_V8_REQUIRE_VALID_HANDLE_RETURN(false);
 
-  if (blink_glue::IsScriptForbidden())
+  if (blink_glue::IsScriptForbidden()) {
     return false;
+  }
 
   if (code.empty()) {
     NOTREACHED() << "invalid input parameter";
@@ -1112,8 +1142,9 @@ v8::Local<v8::Context> CefV8ContextImpl::GetV8Context() {
 blink::WebLocalFrame* CefV8ContextImpl::GetWebFrame() {
   CEF_REQUIRE_RT();
 
-  if (blink_glue::IsScriptForbidden())
+  if (blink_glue::IsScriptForbidden()) {
     return nullptr;
+  }
 
   v8::HandleScope handle_scope(handle_->isolate());
   v8::Local<v8::Context> context = GetV8Context();
@@ -1141,8 +1172,9 @@ CefV8ValueImpl::Handle::~Handle() {
       if (context_state_.get()) {
         // If the associated context is still valid then delete |tracker_|.
         // Otherwise, |tracker_| will already have been deleted.
-        if (context_state_->IsValid())
+        if (context_state_->IsValid()) {
           context_state_->DeleteTrackObject(tracker_);
+        }
       } else {
         GetIsolateManager()->DeleteGlobalTrackObject(tracker_);
       }
@@ -1163,8 +1195,9 @@ CefV8ValueImpl::Handle::~Handle() {
 CefV8ValueImpl::Handle::handleType CefV8ValueImpl::Handle::GetNewV8Handle(
     bool should_persist) {
   DCHECK(IsValid());
-  if (should_persist && !should_persist_)
+  if (should_persist && !should_persist_) {
     should_persist_ = true;
+  }
   return handleType::New(isolate(), handle_);
 }
 
@@ -1403,8 +1436,9 @@ CefRefPtr<CefV8Value> CefV8Value::CreateArrayBuffer(
   V8TrackArrayBuffer* tracker =
       new V8TrackArrayBuffer(isolate, release_callback);
 
-  if (release_callback)
+  if (release_callback) {
     release_callback->AddRef();
+  }
 
   auto deleter = [](void* data, size_t length, void* deleter_data) {
     auto* release_callback =
@@ -1523,10 +1557,12 @@ CefV8ValueImpl::CefV8ValueImpl(v8::Isolate* isolate,
 }
 
 CefV8ValueImpl::~CefV8ValueImpl() {
-  if (type_ == TYPE_STRING)
+  if (type_ == TYPE_STRING) {
     cef_string_clear(&string_value_);
-  if (handle_.get())
+  }
+  if (handle_.get()) {
     handle_->SetWeakIfNecessary();
+  }
 }
 
 void CefV8ValueImpl::InitFromV8Value(v8::Local<v8::Context> context,
@@ -1754,8 +1790,9 @@ bool CefV8ValueImpl::IsSame(CefRefPtr<CefV8Value> that) {
   CEF_V8_REQUIRE_MLT_RETURN(false);
 
   CefV8ValueImpl* thatValue = static_cast<CefV8ValueImpl*>(that.get());
-  if (!thatValue || !thatValue->IsValid() || type_ != thatValue->type_)
+  if (!thatValue || !thatValue->IsValid() || type_ != thatValue->type_) {
     return false;
+  }
 
   switch (type_) {
     case TYPE_UNDEFINED:
@@ -1787,48 +1824,54 @@ bool CefV8ValueImpl::IsSame(CefRefPtr<CefV8Value> that) {
 
 bool CefV8ValueImpl::GetBoolValue() {
   CEF_V8_REQUIRE_ISOLATE_RETURN(false);
-  if (type_ == TYPE_BOOL)
+  if (type_ == TYPE_BOOL) {
     return bool_value_;
+  }
   return false;
 }
 
 int32 CefV8ValueImpl::GetIntValue() {
   CEF_V8_REQUIRE_ISOLATE_RETURN(0);
-  if (type_ == TYPE_INT || type_ == TYPE_UINT)
+  if (type_ == TYPE_INT || type_ == TYPE_UINT) {
     return int_value_;
+  }
   return 0;
 }
 
 uint32 CefV8ValueImpl::GetUIntValue() {
   CEF_V8_REQUIRE_ISOLATE_RETURN(0);
-  if (type_ == TYPE_INT || type_ == TYPE_UINT)
+  if (type_ == TYPE_INT || type_ == TYPE_UINT) {
     return uint_value_;
+  }
   return 0;
 }
 
 double CefV8ValueImpl::GetDoubleValue() {
   CEF_V8_REQUIRE_ISOLATE_RETURN(0.);
-  if (type_ == TYPE_DOUBLE)
+  if (type_ == TYPE_DOUBLE) {
     return double_value_;
-  else if (type_ == TYPE_INT)
+  } else if (type_ == TYPE_INT) {
     return int_value_;
-  else if (type_ == TYPE_UINT)
+  } else if (type_ == TYPE_UINT) {
     return uint_value_;
+  }
   return 0.;
 }
 
 CefBaseTime CefV8ValueImpl::GetDateValue() {
   CEF_V8_REQUIRE_ISOLATE_RETURN(CefBaseTime());
-  if (type_ == TYPE_DATE)
+  if (type_ == TYPE_DATE) {
     return date_value_;
+  }
   return CefBaseTime();
 }
 
 CefString CefV8ValueImpl::GetStringValue() {
   CefString rv;
   CEF_V8_REQUIRE_ISOLATE_RETURN(rv);
-  if (type_ == TYPE_STRING)
+  if (type_ == TYPE_STRING) {
     rv = CefString(&string_value_);
+  }
   return rv;
 }
 
@@ -2117,12 +2160,14 @@ bool CefV8ValueImpl::SetValue(const CefString& key,
   CefRefPtr<CefV8Accessor> accessorPtr;
 
   V8TrackObject* tracker = V8TrackObject::Unwrap(context, obj);
-  if (tracker)
+  if (tracker) {
     accessorPtr = tracker->GetAccessor();
+  }
 
   // Verify that an accessor exists for this object.
-  if (!accessorPtr.get())
+  if (!accessorPtr.get()) {
     return false;
+  }
 
   v8::AccessorNameGetterCallback getter = AccessorNameGetterCallbackImpl;
   v8::AccessorNameSetterCallback setter =
@@ -2207,8 +2252,9 @@ CefRefPtr<CefBaseRefCounted> CefV8ValueImpl::GetUserData() {
   v8::Local<v8::Object> obj = value->ToObject(context).ToLocalChecked();
 
   V8TrackObject* tracker = V8TrackObject::Unwrap(context, obj);
-  if (tracker)
+  if (tracker) {
     return tracker->GetUserData();
+  }
 
   return nullptr;
 }
@@ -2229,8 +2275,9 @@ int CefV8ValueImpl::GetExternallyAllocatedMemory() {
   v8::Local<v8::Object> obj = value->ToObject(context).ToLocalChecked();
 
   V8TrackObject* tracker = V8TrackObject::Unwrap(context, obj);
-  if (tracker)
+  if (tracker) {
     return tracker->GetExternallyAllocatedMemory();
+  }
 
   return 0;
 }
@@ -2251,8 +2298,9 @@ int CefV8ValueImpl::AdjustExternallyAllocatedMemory(int change_in_bytes) {
   v8::Local<v8::Object> obj = value->ToObject(context).ToLocalChecked();
 
   V8TrackObject* tracker = V8TrackObject::Unwrap(context, obj);
-  if (tracker)
+  if (tracker) {
     return tracker->AdjustExternallyAllocatedMemory(change_in_bytes);
+  }
 
   return 0;
 }
@@ -2302,8 +2350,9 @@ CefV8ValueImpl::GetArrayBufferReleaseCallback() {
   v8::Local<v8::Object> obj = value->ToObject(context).ToLocalChecked();
 
   V8TrackArrayBuffer* tracker = V8TrackArrayBuffer::Unwrap(context, obj);
-  if (tracker)
+  if (tracker) {
     return tracker->GetReleaseCallback();
+  }
 
   return nullptr;
 }
@@ -2381,8 +2430,9 @@ CefRefPtr<CefV8Handler> CefV8ValueImpl::GetFunctionHandler() {
 
   v8::Local<v8::Object> obj = value->ToObject(context).ToLocalChecked();
   V8TrackObject* tracker = V8TrackObject::Unwrap(context, obj);
-  if (tracker)
+  if (tracker) {
     return tracker->GetHandler();
+  }
 
   return nullptr;
 }
@@ -2475,8 +2525,9 @@ CefRefPtr<CefV8Value> CefV8ValueImpl::ExecuteFunctionWithContext(
     }
   }
 
-  if (argv)
+  if (argv) {
     delete[] argv;
+  }
 
   return retval;
 }
@@ -2554,12 +2605,14 @@ bool CefV8ValueImpl::HasCaught(v8::Local<v8::Context> context,
                                v8::TryCatch& try_catch) {
   if (try_catch.HasCaught()) {
     last_exception_ = new CefV8ExceptionImpl(context, try_catch.Message());
-    if (rethrow_exceptions_)
+    if (rethrow_exceptions_) {
       try_catch.ReThrow();
+    }
     return true;
   } else {
-    if (last_exception_.get())
+    if (last_exception_.get()) {
       last_exception_ = nullptr;
+    }
     return false;
   }
 }
@@ -2574,8 +2627,9 @@ CefRefPtr<CefV8StackTrace> CefV8StackTrace::GetCurrent(int frame_limit) {
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(
       isolate, frame_limit, v8::StackTrace::kDetailed);
-  if (stackTrace.IsEmpty())
+  if (stackTrace.IsEmpty()) {
     return nullptr;
+  }
   return new CefV8StackTraceImpl(isolate, stackTrace);
 }
 
@@ -2587,9 +2641,10 @@ CefV8StackTraceImpl::CefV8StackTraceImpl(v8::Isolate* isolate,
     int frame_count = handle->GetFrameCount();
     if (frame_count > 0) {
       frames_.reserve(frame_count);
-      for (int i = 0; i < frame_count; ++i)
+      for (int i = 0; i < frame_count; ++i) {
         frames_.push_back(
             new CefV8StackFrameImpl(isolate, handle->GetFrame(isolate, i)));
+      }
     }
   }
 }
@@ -2605,8 +2660,9 @@ int CefV8StackTraceImpl::GetFrameCount() {
 }
 
 CefRefPtr<CefV8StackFrame> CefV8StackTraceImpl::GetFrame(int index) {
-  if (index < 0 || index >= static_cast<int>(frames_.size()))
+  if (index < 0 || index >= static_cast<int>(frames_.size())) {
     return nullptr;
+  }
   return frames_[index];
 }
 
@@ -2615,8 +2671,9 @@ CefRefPtr<CefV8StackFrame> CefV8StackTraceImpl::GetFrame(int index) {
 CefV8StackFrameImpl::CefV8StackFrameImpl(v8::Isolate* isolate,
                                          v8::Local<v8::StackFrame> handle)
     : line_number_(0), column_(0), is_eval_(false), is_constructor_(false) {
-  if (handle.IsEmpty())
+  if (handle.IsEmpty()) {
     return;
+  }
   GetCefString(isolate, handle->GetScriptName(), script_name_);
   GetCefString(isolate, handle->GetScriptNameOrSourceURL(),
                script_name_or_source_url_);
diff --git a/libcef_dll/base/cef_callback_helpers.cc b/libcef_dll/base/cef_callback_helpers.cc
index dab20f4eb..1f75fba3d 100644
--- a/libcef_dll/base/cef_callback_helpers.cc
+++ b/libcef_dll/base/cef_callback_helpers.cc
@@ -28,8 +28,9 @@ ScopedClosureRunner::~ScopedClosureRunner() {
 }
 
 void ScopedClosureRunner::RunAndReset() {
-  if (closure_)
+  if (closure_) {
     std::move(closure_).Run();
+  }
 }
 
 void ScopedClosureRunner::ReplaceClosure(OnceClosure closure) {
diff --git a/libcef_dll/base/cef_weak_ptr.cc b/libcef_dll/base/cef_weak_ptr.cc
index c077c6185..709500e6f 100644
--- a/libcef_dll/base/cef_weak_ptr.cc
+++ b/libcef_dll/base/cef_weak_ptr.cc
@@ -68,8 +68,9 @@ WeakReferenceOwner::~WeakReferenceOwner() {
 
 WeakReference WeakReferenceOwner::GetRef() const {
   // If we hold the last reference to the Flag then detach the ThreadChecker.
-  if (!HasRefs())
+  if (!HasRefs()) {
     flag_->DetachFromThread();
+  }
 
   return WeakReference(flag_);
 }
diff --git a/libcef_dll/cpptoc/cpptoc_ref_counted.h b/libcef_dll/cpptoc/cpptoc_ref_counted.h
index cbd9c648e..d7a04e769 100644
--- a/libcef_dll/cpptoc/cpptoc_ref_counted.h
+++ b/libcef_dll/cpptoc/cpptoc_ref_counted.h
@@ -23,8 +23,9 @@ class CefCppToCRefCounted : public CefBaseRefCounted {
   // Create a new wrapper instance and associated structure reference for
   // passing an object instance the other side.
   static StructName* Wrap(CefRefPtr<BaseName> c) {
-    if (!c.get())
+    if (!c.get()) {
       return nullptr;
+    }
 
     // Wrap our object with the CefCppToCRefCounted class.
     ClassName* wrapper = new ClassName();
@@ -39,16 +40,18 @@ class CefCppToCRefCounted : public CefBaseRefCounted {
   // Retrieve the underlying object instance for a structure reference passed
   // back from the other side.
   static CefRefPtr<BaseName> Unwrap(StructName* s) {
-    if (!s)
+    if (!s) {
       return nullptr;
+    }
 
     // Cast our structure to the wrapper structure type.
     WrapperStruct* wrapperStruct = GetWrapperStruct(s);
 
     // If the type does not match this object then we need to unwrap as the
     // derived type.
-    if (wrapperStruct->type_ != kWrapperType)
+    if (wrapperStruct->type_ != kWrapperType) {
       return UnwrapDerived(wrapperStruct->type_, s);
+    }
 
     // Add the underlying object instance to a smart pointer.
     CefRefPtr<BaseName> objectPtr(wrapperStruct->object_);
@@ -143,8 +146,9 @@ class CefCppToCRefCounted : public CefBaseRefCounted {
 
   static void CEF_CALLBACK struct_add_ref(cef_base_ref_counted_t* base) {
     DCHECK(base);
-    if (!base)
+    if (!base) {
       return;
+    }
 
     WrapperStruct* wrapperStruct =
         GetWrapperStruct(reinterpret_cast<StructName*>(base));
@@ -156,8 +160,9 @@ class CefCppToCRefCounted : public CefBaseRefCounted {
 
   static int CEF_CALLBACK struct_release(cef_base_ref_counted_t* base) {
     DCHECK(base);
-    if (!base)
+    if (!base) {
       return 0;
+    }
 
     WrapperStruct* wrapperStruct =
         GetWrapperStruct(reinterpret_cast<StructName*>(base));
@@ -169,8 +174,9 @@ class CefCppToCRefCounted : public CefBaseRefCounted {
 
   static int CEF_CALLBACK struct_has_one_ref(cef_base_ref_counted_t* base) {
     DCHECK(base);
-    if (!base)
+    if (!base) {
       return 0;
+    }
 
     WrapperStruct* wrapperStruct =
         GetWrapperStruct(reinterpret_cast<StructName*>(base));
@@ -183,8 +189,9 @@ class CefCppToCRefCounted : public CefBaseRefCounted {
   static int CEF_CALLBACK
   struct_has_at_least_one_ref(cef_base_ref_counted_t* base) {
     DCHECK(base);
-    if (!base)
+    if (!base) {
       return 0;
+    }
 
     WrapperStruct* wrapperStruct =
         GetWrapperStruct(reinterpret_cast<StructName*>(base));
diff --git a/libcef_dll/cpptoc/cpptoc_scoped.h b/libcef_dll/cpptoc/cpptoc_scoped.h
index 50ce2a8cf..11fe3d964 100644
--- a/libcef_dll/cpptoc/cpptoc_scoped.h
+++ b/libcef_dll/cpptoc/cpptoc_scoped.h
@@ -34,8 +34,9 @@ class CefCppToCScoped : public CefBaseScoped {
   //   struct->del(struct);
   // }
   static StructName* WrapOwn(CefOwnPtr<BaseName> c) {
-    if (!c)
+    if (!c) {
       return nullptr;
+    }
 
     // Wrap our object with the CefCppToC class.
     ClassName* wrapper = new ClassName();
@@ -60,8 +61,9 @@ class CefCppToCScoped : public CefBaseScoped {
   //   // Access |struct| here but you can't delete it.
   // }
   static CefOwnPtr<ClassName> WrapRaw(CefRawPtr<BaseName> c) {
-    if (!c)
+    if (!c) {
       return CefOwnPtr<ClassName>();
+    }
 
     // Wrap our object with the CefCppToC class.
     ClassName* wrapper = new ClassName();
@@ -80,16 +82,18 @@ class CefCppToCScoped : public CefBaseScoped {
   //   // |struct| has been deleted and should no longer be accessed.
   // }
   static CefOwnPtr<BaseName> UnwrapOwn(StructName* s) {
-    if (!s)
+    if (!s) {
       return CefOwnPtr<BaseName>();
+    }
 
     // Cast our structure to the wrapper structure type.
     WrapperStruct* wrapperStruct = GetWrapperStruct(s);
 
     // If the type does not match this object then we need to unwrap as the
     // derived type.
-    if (wrapperStruct->type_ != kWrapperType)
+    if (wrapperStruct->type_ != kWrapperType) {
       return UnwrapDerivedOwn(wrapperStruct->type_, s);
+    }
 
     // We should own the underlying object currently.
     DCHECK(wrapperStruct->wrapper_->owned_);
@@ -114,16 +118,18 @@ class CefCppToCScoped : public CefBaseScoped {
   //   // |struct| is still valid.
   // }
   static CefRawPtr<BaseName> UnwrapRaw(StructName* s) {
-    if (!s)
+    if (!s) {
       return nullptr;
+    }
 
     // Cast our structure to the wrapper structure type.
     WrapperStruct* wrapperStruct = GetWrapperStruct(s);
 
     // If the type does not match this object then we need to unwrap as the
     // derived type.
-    if (wrapperStruct->type_ != kWrapperType)
+    if (wrapperStruct->type_ != kWrapperType) {
       return UnwrapDerivedRaw(wrapperStruct->type_, s);
+    }
 
     // Return the underlying object instance.
     return wrapperStruct->object_;
@@ -164,8 +170,9 @@ class CefCppToCScoped : public CefBaseScoped {
 
   virtual ~CefCppToCScoped() {
     // Only delete the underlying object if we own it.
-    if (owned_ && wrapper_struct_.object_)
+    if (owned_ && wrapper_struct_.object_) {
       delete wrapper_struct_.object_;
+    }
   }
 
  private:
@@ -184,8 +191,9 @@ class CefCppToCScoped : public CefBaseScoped {
 
     cef_base_scoped_t* base = reinterpret_cast<cef_base_scoped_t*>(GetStruct());
     base->size = sizeof(StructName);
-    if (owned)
+    if (owned) {
       base->del = struct_del;
+    }
   }
 
   static WrapperStruct* GetWrapperStruct(StructName* s) {
@@ -205,8 +213,9 @@ class CefCppToCScoped : public CefBaseScoped {
 
   static void CEF_CALLBACK struct_del(cef_base_scoped_t* base) {
     DCHECK(base);
-    if (!base)
+    if (!base) {
       return;
+    }
 
     WrapperStruct* wrapperStruct =
         GetWrapperStruct(reinterpret_cast<StructName*>(base));
diff --git a/libcef_dll/ctocpp/ctocpp_ref_counted.h b/libcef_dll/ctocpp/ctocpp_ref_counted.h
index 0b0a4bc6a..429d246aa 100644
--- a/libcef_dll/ctocpp/ctocpp_ref_counted.h
+++ b/libcef_dll/ctocpp/ctocpp_ref_counted.h
@@ -65,16 +65,18 @@ class CefCToCppRefCounted : public BaseName {
   void UnderlyingAddRef() const {
     cef_base_ref_counted_t* base =
         reinterpret_cast<cef_base_ref_counted_t*>(GetStruct());
-    if (base->add_ref)
+    if (base->add_ref) {
       base->add_ref(base);
+    }
   }
 
   NO_SANITIZE("cfi-icall")
   bool UnderlyingRelease() const {
     cef_base_ref_counted_t* base =
         reinterpret_cast<cef_base_ref_counted_t*>(GetStruct());
-    if (!base->release)
+    if (!base->release) {
       return false;
+    }
     return base->release(base) ? true : false;
   }
 
@@ -82,8 +84,9 @@ class CefCToCppRefCounted : public BaseName {
   bool UnderlyingHasOneRef() const {
     cef_base_ref_counted_t* base =
         reinterpret_cast<cef_base_ref_counted_t*>(GetStruct());
-    if (!base->has_one_ref)
+    if (!base->has_one_ref) {
       return false;
+    }
     return base->has_one_ref(base) ? true : false;
   }
 
@@ -91,8 +94,9 @@ class CefCToCppRefCounted : public BaseName {
   bool UnderlyingHasAtLeastOneRef() const {
     cef_base_ref_counted_t* base =
         reinterpret_cast<cef_base_ref_counted_t*>(GetStruct());
-    if (!base->has_at_least_one_ref)
+    if (!base->has_at_least_one_ref) {
       return false;
+    }
     return base->has_at_least_one_ref(base) ? true : false;
   }
 
@@ -111,8 +115,9 @@ struct CefCToCppRefCounted<ClassName, BaseName, StructName>::WrapperStruct {
 template <class ClassName, class BaseName, class StructName>
 CefRefPtr<BaseName> CefCToCppRefCounted<ClassName, BaseName, StructName>::Wrap(
     StructName* s) {
-  if (!s)
+  if (!s) {
     return nullptr;
+  }
 
   // Wrap their structure with the CefCToCppRefCounted object.
   WrapperStruct* wrapperStruct = new WrapperStruct;
@@ -131,15 +136,17 @@ CefRefPtr<BaseName> CefCToCppRefCounted<ClassName, BaseName, StructName>::Wrap(
 template <class ClassName, class BaseName, class StructName>
 StructName* CefCToCppRefCounted<ClassName, BaseName, StructName>::Unwrap(
     CefRefPtr<BaseName> c) {
-  if (!c.get())
+  if (!c.get()) {
     return nullptr;
+  }
 
   WrapperStruct* wrapperStruct = GetWrapperStruct(c.get());
 
   // If the type does not match this object then we need to unwrap as the
   // derived type.
-  if (wrapperStruct->type_ != kWrapperType)
+  if (wrapperStruct->type_ != kWrapperType) {
     return UnwrapDerived(wrapperStruct->type_, c.get());
+  }
 
   // Add a reference to the CefCppToC wrapper object on the other side that
   // will be released once the structure is received.
diff --git a/libcef_dll/ctocpp/ctocpp_scoped.h b/libcef_dll/ctocpp/ctocpp_scoped.h
index da6c27eac..be1bb8480 100644
--- a/libcef_dll/ctocpp/ctocpp_scoped.h
+++ b/libcef_dll/ctocpp/ctocpp_scoped.h
@@ -106,8 +106,9 @@ struct CefCToCppScoped<ClassName, BaseName, StructName>::WrapperStruct {
 template <class ClassName, class BaseName, class StructName>
 CefOwnPtr<BaseName> CefCToCppScoped<ClassName, BaseName, StructName>::Wrap(
     StructName* s) {
-  if (!s)
+  if (!s) {
     return CefOwnPtr<BaseName>();
+  }
 
   // Wrap their structure with the CefCToCpp object.
   WrapperStruct* wrapperStruct = new WrapperStruct;
@@ -120,15 +121,17 @@ CefOwnPtr<BaseName> CefCToCppScoped<ClassName, BaseName, StructName>::Wrap(
 template <class ClassName, class BaseName, class StructName>
 StructName* CefCToCppScoped<ClassName, BaseName, StructName>::UnwrapOwn(
     CefOwnPtr<BaseName> c) {
-  if (!c.get())
+  if (!c.get()) {
     return nullptr;
+  }
 
   WrapperStruct* wrapperStruct = GetWrapperStruct(c.get());
 
   // If the type does not match this object then we need to unwrap as the
   // derived type.
-  if (wrapperStruct->type_ != kWrapperType)
+  if (wrapperStruct->type_ != kWrapperType) {
     return UnwrapDerivedOwn(wrapperStruct->type_, std::move(c));
+  }
 
   StructName* orig_struct = wrapperStruct->struct_;
 
@@ -149,15 +152,17 @@ StructName* CefCToCppScoped<ClassName, BaseName, StructName>::UnwrapOwn(
 template <class ClassName, class BaseName, class StructName>
 StructName* CefCToCppScoped<ClassName, BaseName, StructName>::UnwrapRaw(
     CefRawPtr<BaseName> c) {
-  if (!c)
+  if (!c) {
     return nullptr;
+  }
 
   WrapperStruct* wrapperStruct = GetWrapperStruct(c);
 
   // If the type does not match this object then we need to unwrap as the
   // derived type.
-  if (wrapperStruct->type_ != kWrapperType)
+  if (wrapperStruct->type_ != kWrapperType) {
     return UnwrapDerivedRaw(wrapperStruct->type_, c);
+  }
 
   // Return the original structure.
   return wrapperStruct->struct_;
@@ -177,8 +182,9 @@ void CefCToCppScoped<ClassName, BaseName, StructName>::operator delete(
 
   // If we own the object (base->del != NULL) then notify the other side that
   // the object has been deleted.
-  if (base && base->del)
+  if (base && base->del) {
     base->del(base);
+  }
 
   // Delete the wrapper structure without executing ~CefCToCppScoped() an
   // additional time.
diff --git a/libcef_dll/sandbox/sandbox_mac.mm b/libcef_dll/sandbox/sandbox_mac.mm
index cfdcae75e..f3afaff3e 100644
--- a/libcef_dll/sandbox/sandbox_mac.mm
+++ b/libcef_dll/sandbox/sandbox_mac.mm
@@ -58,8 +58,9 @@ CefScopedSandboxContext::~CefScopedSandboxContext() {
 }
 
 bool CefScopedSandboxContext::Initialize(int argc, char** argv) {
-  if (sandbox_context_)
+  if (sandbox_context_) {
     return false;
+  }
   sandbox_context_ = cef_sandbox_initialize(argc, argv);
   return !!sandbox_context_;
 }
diff --git a/libcef_dll/transfer_util.cc b/libcef_dll/transfer_util.cc
index eb6a79c55..47ad13590 100644
--- a/libcef_dll/transfer_util.cc
+++ b/libcef_dll/transfer_util.cc
@@ -18,8 +18,9 @@ void transfer_string_list_contents(cef_string_list_t fromList,
 void transfer_string_list_contents(const StringList& fromList,
                                    cef_string_list_t toList) {
   size_t size = fromList.size();
-  for (size_t i = 0; i < size; ++i)
+  for (size_t i = 0; i < size; ++i) {
     cef_string_list_append(toList, fromList[i].GetStruct());
+  }
 }
 
 void transfer_string_map_contents(cef_string_map_t fromMap, StringMap& toMap) {
@@ -37,8 +38,9 @@ void transfer_string_map_contents(cef_string_map_t fromMap, StringMap& toMap) {
 void transfer_string_map_contents(const StringMap& fromMap,
                                   cef_string_map_t toMap) {
   StringMap::const_iterator it = fromMap.begin();
-  for (; it != fromMap.end(); ++it)
+  for (; it != fromMap.end(); ++it) {
     cef_string_map_append(toMap, it->first.GetStruct(), it->second.GetStruct());
+  }
 }
 
 void transfer_string_multimap_contents(cef_string_multimap_t fromMap,
diff --git a/libcef_dll/wrapper/cef_browser_info_map.h b/libcef_dll/wrapper/cef_browser_info_map.h
index ef638798f..24459ce78 100644
--- a/libcef_dll/wrapper/cef_browser_info_map.h
+++ b/libcef_dll/wrapper/cef_browser_info_map.h
@@ -70,24 +70,28 @@ class CefBrowserInfoMap {
   // used to evaluate or remove the object at the same time. If the object is
   // removed using the Visitor the caller is responsible for destroying it.
   ObjectType Find(int browser_id, IdType info_id, Visitor* vistor) {
-    if (browser_info_map_.empty())
+    if (browser_info_map_.empty()) {
       return ObjectType();
+    }
 
     typename BrowserInfoMap::iterator it_browser =
         browser_info_map_.find(browser_id);
-    if (it_browser == browser_info_map_.end())
+    if (it_browser == browser_info_map_.end()) {
       return ObjectType();
+    }
 
     InfoMap* info_map = it_browser->second;
     typename InfoMap::iterator it_info = info_map->find(info_id);
-    if (it_info == info_map->end())
+    if (it_info == info_map->end()) {
       return ObjectType();
+    }
 
     ObjectType info = it_info->second;
 
     bool remove = false;
-    if (vistor)
+    if (vistor) {
       vistor->OnNextInfo(browser_id, it_info->first, info, &remove);
+    }
     if (remove) {
       info_map->erase(it_info);
 
@@ -106,8 +110,9 @@ class CefBrowserInfoMap {
   void FindAll(Visitor* visitor) {
     DCHECK(visitor);
 
-    if (browser_info_map_.empty())
+    if (browser_info_map_.empty()) {
       return;
+    }
 
     bool remove, keepgoing = true;
 
@@ -121,13 +126,15 @@ class CefBrowserInfoMap {
         keepgoing = visitor->OnNextInfo(it_browser->first, it_info->first,
                                         it_info->second, &remove);
 
-        if (remove)
+        if (remove) {
           info_map->erase(it_info++);
-        else
+        } else {
           ++it_info;
+        }
 
-        if (!keepgoing)
+        if (!keepgoing) {
           break;
+        }
       }
 
       if (info_map->empty()) {
@@ -138,8 +145,9 @@ class CefBrowserInfoMap {
         ++it_browser;
       }
 
-      if (!keepgoing)
+      if (!keepgoing) {
         break;
+      }
     }
   }
 
@@ -148,13 +156,15 @@ class CefBrowserInfoMap {
   void FindAll(int browser_id, Visitor* visitor) {
     DCHECK(visitor);
 
-    if (browser_info_map_.empty())
+    if (browser_info_map_.empty()) {
       return;
+    }
 
     typename BrowserInfoMap::iterator it_browser =
         browser_info_map_.find(browser_id);
-    if (it_browser == browser_info_map_.end())
+    if (it_browser == browser_info_map_.end()) {
       return;
+    }
 
     InfoMap* info_map = it_browser->second;
     bool remove, keepgoing;
@@ -165,13 +175,15 @@ class CefBrowserInfoMap {
       keepgoing = visitor->OnNextInfo(browser_id, it_info->first,
                                       it_info->second, &remove);
 
-      if (remove)
+      if (remove) {
         info_map->erase(it_info++);
-      else
+      } else {
         ++it_info;
+      }
 
-      if (!keepgoing)
+      if (!keepgoing) {
         break;
+      }
     }
 
     if (info_map->empty()) {
@@ -186,43 +198,49 @@ class CefBrowserInfoMap {
 
   // Returns the number of objects in the map.
   size_t size() const {
-    if (browser_info_map_.empty())
+    if (browser_info_map_.empty()) {
       return 0;
+    }
 
     size_t size = 0;
     typename BrowserInfoMap::const_iterator it_browser =
         browser_info_map_.begin();
-    for (; it_browser != browser_info_map_.end(); ++it_browser)
+    for (; it_browser != browser_info_map_.end(); ++it_browser) {
       size += it_browser->second->size();
+    }
     return size;
   }
 
   // Returns the number of objects in the map that are associated with the
   // specified browser.
   size_t size(int browser_id) const {
-    if (browser_info_map_.empty())
+    if (browser_info_map_.empty()) {
       return 0;
+    }
 
     typename BrowserInfoMap::const_iterator it_browser =
         browser_info_map_.find(browser_id);
-    if (it_browser != browser_info_map_.end())
+    if (it_browser != browser_info_map_.end()) {
       return it_browser->second->size();
+    }
 
     return 0;
   }
 
   // Remove all objects from the map. The objects will be destructed.
   void clear() {
-    if (browser_info_map_.empty())
+    if (browser_info_map_.empty()) {
       return;
+    }
 
     typename BrowserInfoMap::const_iterator it_browser =
         browser_info_map_.begin();
     for (; it_browser != browser_info_map_.end(); ++it_browser) {
       InfoMap* info_map = it_browser->second;
       typename InfoMap::const_iterator it_info = info_map->begin();
-      for (; it_info != info_map->end(); ++it_info)
+      for (; it_info != info_map->end(); ++it_info) {
         Traits::Destruct(it_info->second);
+      }
       delete info_map;
     }
     browser_info_map_.clear();
@@ -231,18 +249,21 @@ class CefBrowserInfoMap {
   // Remove all objects from the map that are associated with the specified
   // browser. The objects will be destructed.
   void clear(int browser_id) {
-    if (browser_info_map_.empty())
+    if (browser_info_map_.empty()) {
       return;
+    }
 
     typename BrowserInfoMap::iterator it_browser =
         browser_info_map_.find(browser_id);
-    if (it_browser == browser_info_map_.end())
+    if (it_browser == browser_info_map_.end()) {
       return;
+    }
 
     InfoMap* info_map = it_browser->second;
     typename InfoMap::const_iterator it_info = info_map->begin();
-    for (; it_info != info_map->end(); ++it_info)
+    for (; it_info != info_map->end(); ++it_info) {
       Traits::Destruct(it_info->second);
+    }
 
     browser_info_map_.erase(it_browser);
     delete info_map;
diff --git a/libcef_dll/wrapper/cef_byte_read_handler.cc b/libcef_dll/wrapper/cef_byte_read_handler.cc
index dbb518187..c1690e680 100644
--- a/libcef_dll/wrapper/cef_byte_read_handler.cc
+++ b/libcef_dll/wrapper/cef_byte_read_handler.cc
@@ -27,8 +27,9 @@ int CefByteReadHandler::Seek(int64 offset, int whence) {
   base::AutoLock lock_scope(lock_);
   switch (whence) {
     case SEEK_CUR:
-      if (offset_ + offset > size_ || offset_ + offset < 0)
+      if (offset_ + offset > size_ || offset_ + offset < 0) {
         break;
+      }
       offset_ += offset;
       rv = 0;
       break;
@@ -38,15 +39,17 @@ int CefByteReadHandler::Seek(int64 offset, int whence) {
 #else
       int64 offset_abs = std::abs(offset);
 #endif
-      if (offset_abs > size_)
+      if (offset_abs > size_) {
         break;
+      }
       offset_ = size_ - offset_abs;
       rv = 0;
       break;
     }
     case SEEK_SET:
-      if (offset > size_ || offset < 0)
+      if (offset > size_ || offset < 0) {
         break;
+      }
       offset_ = offset;
       rv = 0;
       break;
diff --git a/libcef_dll/wrapper/cef_message_router.cc b/libcef_dll/wrapper/cef_message_router.cc
index 5d702d593..13fd31b98 100644
--- a/libcef_dll/wrapper/cef_message_router.cc
+++ b/libcef_dll/wrapper/cef_message_router.cc
@@ -175,8 +175,9 @@ class IdGenerator {
 
   T GetNextId() {
     T id = ++next_id_;
-    if (id == kReservedId)  // In case the integer value wraps.
+    if (id == kReservedId) {  // In case the integer value wraps.
       id = ++next_id_;
+    }
     return id;
   }
 
@@ -308,8 +309,9 @@ class CefMessageRouterBrowserSideImpl : public CefMessageRouterBrowserSide {
                       Handler* handler) override {
     CEF_REQUIRE_UI_THREAD();
 
-    if (browser_query_info_map_.empty())
+    if (browser_query_info_map_.empty()) {
       return 0;
+    }
 
     if (handler) {
       // Need to iterate over each QueryInfo object to test the handler.
@@ -321,8 +323,9 @@ class CefMessageRouterBrowserSideImpl : public CefMessageRouterBrowserSide {
                         InfoIdType info_id,
                         InfoObjectType info,
                         bool* remove) override {
-          if (info->handler == handler_)
+          if (info->handler == handler_) {
             count_++;
+          }
           return true;
         }
 
@@ -362,8 +365,9 @@ class CefMessageRouterBrowserSideImpl : public CefMessageRouterBrowserSide {
 
   void OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
                       CefRefPtr<CefFrame> frame) override {
-    if (frame->IsMain())
+    if (frame->IsMain()) {
       CancelPendingFor(browser, nullptr, false);
+    }
   }
 
   bool OnProcessMessageReceived(CefRefPtr<CefBrowser> browser,
@@ -404,8 +408,9 @@ class CefMessageRouterBrowserSideImpl : public CefMessageRouterBrowserSide {
         handled = (*it_handler)
                       ->OnQuery(browser, frame, query_id, request, persistent,
                                 callback.get());
-        if (handled)
+        if (handled) {
           break;
+        }
       }
 
       // If the query isn't handled nothing should be keeping a reference to
@@ -505,8 +510,9 @@ class CefMessageRouterBrowserSideImpl : public CefMessageRouterBrowserSide {
     Visitor visitor(always_remove);
     QueryInfo* info =
         browser_query_info_map_.Find(browser_id, query_id, &visitor);
-    if (info)
+    if (info) {
       *removed = visitor.removed();
+    }
     return info;
   }
 
@@ -520,8 +526,9 @@ class CefMessageRouterBrowserSideImpl : public CefMessageRouterBrowserSide {
     QueryInfo* info = GetQueryInfo(browser_id, query_id, false, &removed);
     if (info) {
       SendQuerySuccess(info, response);
-      if (removed)
+      if (removed) {
         delete info;
+      }
     }
   }
 
@@ -593,8 +600,9 @@ class CefMessageRouterBrowserSideImpl : public CefMessageRouterBrowserSide {
 
   // Cancel a query that has already been sent to a handler.
   void CancelQuery(int64 query_id, QueryInfo* info, bool notify_renderer) {
-    if (notify_renderer)
+    if (notify_renderer) {
       SendQueryFailure(info, kCanceledErrorCode, kCanceledErrorMessage);
+    }
 
     info->handler->OnQueryCanceled(info->browser, info->frame, query_id);
 
@@ -617,8 +625,9 @@ class CefMessageRouterBrowserSideImpl : public CefMessageRouterBrowserSide {
       return;
     }
 
-    if (browser_query_info_map_.empty())
+    if (browser_query_info_map_.empty()) {
       return;
+    }
 
     class Visitor : public BrowserQueryInfoMap::Visitor {
      public:
@@ -814,8 +823,9 @@ class CefMessageRouterRendererSideImpl : public CefMessageRouterRendererSide {
    private:
     // Don't create the context ID until it's actually needed.
     int GetIDForContext(CefRefPtr<CefV8Context> context) {
-      if (context_id_ == kReservedId)
+      if (context_id_ == kReservedId) {
         context_id_ = router_->CreateIDForContext(context);
+      }
       return context_id_;
     }
 
@@ -843,13 +853,15 @@ class CefMessageRouterRendererSideImpl : public CefMessageRouterRendererSide {
                       CefRefPtr<CefV8Context> context) override {
     CEF_REQUIRE_RENDERER_THREAD();
 
-    if (browser_request_info_map_.empty())
+    if (browser_request_info_map_.empty()) {
       return 0;
+    }
 
     if (context.get()) {
       const int context_id = GetIDForContext(context, false);
-      if (context_id == kReservedId)
+      if (context_id == kReservedId) {
         return 0;  // Nothing associated with the specified context.
+      }
 
       // Need to iterate over each RequestInfo object to test the context.
       class Visitor : public BrowserRequestInfoMap::Visitor {
@@ -860,8 +872,9 @@ class CefMessageRouterRendererSideImpl : public CefMessageRouterRendererSide {
                         InfoIdType info_id,
                         InfoObjectType info,
                         bool* remove) override {
-          if (info_id.first == context_id_)
+          if (info_id.first == context_id_) {
             count_++;
+          }
           return true;
         }
 
@@ -1006,8 +1019,9 @@ class CefMessageRouterRendererSideImpl : public CefMessageRouterRendererSide {
     Visitor visitor(always_remove);
     RequestInfo* info = browser_request_info_map_.Find(
         browser_id, std::make_pair(context_id, request_id), &visitor);
-    if (info)
+    if (info) {
       *removed = visitor.removed();
+    }
     return info;
   }
 
@@ -1121,8 +1135,9 @@ class CefMessageRouterRendererSideImpl : public CefMessageRouterRendererSide {
     bool removed;
     RequestInfo* info =
         GetRequestInfo(browser_id, context_id, request_id, false, &removed);
-    if (!info)
+    if (!info) {
       return;
+    }
 
     CefRefPtr<CefV8Context> context = GetContextByID(context_id);
     if (context && info->success_callback) {
@@ -1132,8 +1147,9 @@ class CefMessageRouterRendererSideImpl : public CefMessageRouterRendererSide {
                                                          args);
     }
 
-    if (removed)
+    if (removed) {
       delete info;
+    }
   }
 
   // Execute the onFailure JavaScript callback.
@@ -1147,8 +1163,9 @@ class CefMessageRouterRendererSideImpl : public CefMessageRouterRendererSide {
     bool removed;
     RequestInfo* info =
         GetRequestInfo(browser_id, context_id, request_id, true, &removed);
-    if (!info)
+    if (!info) {
       return;
+    }
 
     CefRefPtr<CefV8Context> context = GetContextByID(context_id);
     if (context && info->failure_callback) {
@@ -1183,8 +1200,9 @@ class CefMessageRouterRendererSideImpl : public CefMessageRouterRendererSide {
     for (; it != context_map_.end(); ++it) {
       if (it->second->IsSame(context)) {
         int context_id = it->first;
-        if (remove)
+        if (remove) {
           context_map_.erase(it);
+        }
         return context_id;
       }
     }
@@ -1196,8 +1214,9 @@ class CefMessageRouterRendererSideImpl : public CefMessageRouterRendererSide {
     CEF_REQUIRE_RENDERER_THREAD();
 
     ContextMap::const_iterator it = context_map_.find(context_id);
-    if (it != context_map_.end())
+    if (it != context_map_.end()) {
       return it->second;
+    }
     return nullptr;
   }
 
@@ -1234,8 +1253,9 @@ CefMessageRouterConfig::CefMessageRouterConfig()
 CefRefPtr<CefMessageRouterBrowserSide> CefMessageRouterBrowserSide::Create(
     const CefMessageRouterConfig& config) {
   CefMessageRouterConfig validated_config = config;
-  if (!ValidateConfig(validated_config))
+  if (!ValidateConfig(validated_config)) {
     return nullptr;
+  }
   return new CefMessageRouterBrowserSideImpl(validated_config);
 }
 
@@ -1243,7 +1263,8 @@ CefRefPtr<CefMessageRouterBrowserSide> CefMessageRouterBrowserSide::Create(
 CefRefPtr<CefMessageRouterRendererSide> CefMessageRouterRendererSide::Create(
     const CefMessageRouterConfig& config) {
   CefMessageRouterConfig validated_config = config;
-  if (!ValidateConfig(validated_config))
+  if (!ValidateConfig(validated_config)) {
     return nullptr;
+  }
   return new CefMessageRouterRendererSideImpl(validated_config);
 }
diff --git a/libcef_dll/wrapper/cef_resource_manager.cc b/libcef_dll/wrapper/cef_resource_manager.cc
index 3c4f70ce8..1df8aeb9b 100644
--- a/libcef_dll/wrapper/cef_resource_manager.cc
+++ b/libcef_dll/wrapper/cef_resource_manager.cc
@@ -25,8 +25,9 @@ namespace {
 std::string GetUrlWithoutQueryOrFragment(const std::string& url) {
   // Find the first instance of '?' or '#'.
   const size_t pos = std::min(url.find('?'), url.find('#'));
-  if (pos != std::string::npos)
+  if (pos != std::string::npos) {
     return url.substr(0, pos);
+  }
 
   return url;
 }
@@ -38,8 +39,9 @@ std::string GetMimeType(const std::string& url) {
   size_t sep = url_without_query.find_last_of(".");
   if (sep != std::string::npos) {
     mime_type = CefGetMimeType(url_without_query.substr(sep + 1));
-    if (!mime_type.empty())
+    if (!mime_type.empty()) {
       return mime_type;
+    }
   }
   return "text/html";
 }
@@ -77,8 +79,9 @@ class ContentProvider : public CefResourceManager::Provider {
         content_.length());
 
     // Determine the mime type a single time if it isn't already set.
-    if (mime_type_.empty())
+    if (mime_type_.empty()) {
       mime_type_ = request->mime_type_resolver().Run(url);
+    }
 
     request->Continue(new CefStreamResourceHandler(mime_type_, stream));
     return true;
@@ -100,10 +103,12 @@ class DirectoryProvider : public CefResourceManager::Provider {
     DCHECK(!directory_path_.empty());
 
     // Normalize the path values.
-    if (url_path_[url_path_.size() - 1] != '/')
+    if (url_path_[url_path_.size() - 1] != '/') {
       url_path_ += '/';
-    if (directory_path_[directory_path_.size() - 1] != PATH_SEP)
+    }
+    if (directory_path_[directory_path_.size() - 1] != PATH_SEP) {
       directory_path_ += PATH_SEP;
+    }
   }
 
   DirectoryProvider(const DirectoryProvider&) = delete;
@@ -183,8 +188,9 @@ class ArchiveProvider : public CefResourceManager::Provider {
     DCHECK(!archive_path_.empty());
 
     // Normalize the path values.
-    if (url_path_[url_path_.size() - 1] != '/')
+    if (url_path_[url_path_.size() - 1] != '/') {
       url_path_ += '/';
+    }
   }
 
   ArchiveProvider(const ArchiveProvider&) = delete;
@@ -255,8 +261,9 @@ class ArchiveProvider : public CefResourceManager::Provider {
     if (!pending_requests_.empty()) {
       // Continue all pending requests.
       PendingRequests::const_iterator it = pending_requests_.begin();
-      for (; it != pending_requests_.end(); ++it)
+      for (; it != pending_requests_.end(); ++it) {
         ContinueRequest(*it);
+      }
       pending_requests_.clear();
     }
   }
@@ -275,8 +282,9 @@ class ArchiveProvider : public CefResourceManager::Provider {
       }
     }
 
-    if (!handler.get())
+    if (!handler.get()) {
       return false;
+    }
 
     request->Continue(handler);
     return true;
@@ -325,8 +333,9 @@ struct CefResourceManager::ProviderEntry {
 
 CefResourceManager::RequestState::~RequestState() {
   // Always execute the callback.
-  if (callback_.get())
+  if (callback_.get()) {
     callback_->Continue();
+  }
 }
 
 // CefResourceManager::Request implementation.
@@ -339,8 +348,9 @@ void CefResourceManager::Request::Continue(
     return;
   }
 
-  if (!state_.get())
+  if (!state_.get()) {
     return;
+  }
 
   // Disassociate |state_| immediately so that Provider::OnRequestCanceled is
   // not called unexpectedly if Provider::OnRequest calls this method and then
@@ -357,8 +367,9 @@ void CefResourceManager::Request::Stop() {
     return;
   }
 
-  if (!state_.get())
+  if (!state_.get()) {
     return;
+  }
 
   // Disassociate |state_| immediately so that Provider::OnRequestCanceled is
   // not called unexpectedly if Provider::OnRequest calls this method and then
@@ -389,8 +400,9 @@ std::unique_ptr<CefResourceManager::RequestState>
 CefResourceManager::Request::SendRequest() {
   CEF_REQUIRE_IO_THREAD();
   Provider* provider = (*state_->current_entry_pos_)->provider_.get();
-  if (!provider->OnRequest(this))
+  if (!provider->OnRequest(this)) {
     return std::move(state_);
+  }
   return std::unique_ptr<RequestState>();
 }
 
@@ -406,8 +418,9 @@ void CefResourceManager::Request::ContinueOnIOThread(
   CEF_REQUIRE_IO_THREAD();
   // The manager may already have been deleted.
   base::WeakPtr<CefResourceManager> manager = state->manager_;
-  if (manager)
+  if (manager) {
     manager->ContinueRequest(std::move(state), handler);
+  }
 }
 
 // static
@@ -416,8 +429,9 @@ void CefResourceManager::Request::StopOnIOThread(
   CEF_REQUIRE_IO_THREAD();
   // The manager may already have been deleted.
   base::WeakPtr<CefResourceManager> manager = state->manager_;
-  if (manager)
+  if (manager) {
     manager->StopRequest(std::move(state));
+  }
 }
 
 // CefResourceManager implementation.
@@ -434,8 +448,9 @@ CefResourceManager::~CefResourceManager() {
   // call back into this manager due to the use of WeakPtr.
   if (!providers_.empty()) {
     ProviderEntryList::iterator it = providers_.begin();
-    for (; it != providers_.end(); ++it)
+    for (; it != providers_.end(); ++it) {
       delete *it;
+    }
     providers_.clear();
   }
 }
@@ -469,8 +484,9 @@ void CefResourceManager::AddProvider(Provider* provider,
                                      int order,
                                      const std::string& identifier) {
   DCHECK(provider);
-  if (!provider)
+  if (!provider) {
     return;
+  }
 
   if (!CefCurrentlyOn(TID_IO)) {
     CefPostTask(TID_IO, base::BindOnce(&CefResourceManager::AddProvider, this,
@@ -489,8 +505,9 @@ void CefResourceManager::AddProvider(Provider* provider,
   // Insert before the first entry with a higher |order| value.
   ProviderEntryList::iterator it = providers_.begin();
   for (; it != providers_.end(); ++it) {
-    if ((*it)->order_ > order)
+    if ((*it)->order_ > order) {
       break;
+    }
   }
 
   providers_.insert(it, new_entry.release());
@@ -503,15 +520,17 @@ void CefResourceManager::RemoveProviders(const std::string& identifier) {
     return;
   }
 
-  if (providers_.empty())
+  if (providers_.empty()) {
     return;
+  }
 
   ProviderEntryList::iterator it = providers_.begin();
   while (it != providers_.end()) {
-    if ((*it)->identifier_ == identifier)
+    if ((*it)->identifier_ == identifier) {
       DeleteProvider(it, false);
-    else
+    } else {
       ++it;
+    }
   }
 }
 
@@ -522,12 +541,14 @@ void CefResourceManager::RemoveAllProviders() {
     return;
   }
 
-  if (providers_.empty())
+  if (providers_.empty()) {
     return;
+  }
 
   ProviderEntryList::iterator it = providers_.begin();
-  while (it != providers_.end())
+  while (it != providers_.end()) {
     DeleteProvider(it, true);
+  }
 }
 
 void CefResourceManager::SetMimeTypeResolver(const MimeTypeResolver& resolver) {
@@ -537,10 +558,11 @@ void CefResourceManager::SetMimeTypeResolver(const MimeTypeResolver& resolver) {
     return;
   }
 
-  if (!resolver.is_null())
+  if (!resolver.is_null()) {
     mime_type_resolver_ = resolver;
-  else
+  } else {
     mime_type_resolver_ = base::BindRepeating(GetMimeType);
+  }
 }
 
 void CefResourceManager::SetUrlFilter(const UrlFilter& filter) {
@@ -550,10 +572,11 @@ void CefResourceManager::SetUrlFilter(const UrlFilter& filter) {
     return;
   }
 
-  if (!filter.is_null())
+  if (!filter.is_null()) {
     url_filter_ = filter;
-  else
+  } else {
     url_filter_ = base::BindRepeating(GetFilteredUrl);
+  }
 }
 
 cef_return_value_t CefResourceManager::OnBeforeResourceLoad(
@@ -605,8 +628,9 @@ CefRefPtr<CefResourceHandler> CefResourceManager::GetResourceHandler(
     CefRefPtr<CefRequest> request) {
   CEF_REQUIRE_IO_THREAD();
 
-  if (pending_handlers_.empty())
+  if (pending_handlers_.empty()) {
     return nullptr;
+  }
 
   CefRefPtr<CefResourceHandler> handler;
 
@@ -635,8 +659,9 @@ bool CefResourceManager::SendRequest(std::unique_ptr<RequestState> state) {
     if (state.get()) {
       // The provider will not handle the request. Move to the next provider if
       // any.
-      if (!IncrementProvider(state.get()))
+      if (!IncrementProvider(state.get())) {
         StopRequest(std::move(state));
+      }
     } else {
       potentially_handled = true;
     }
@@ -657,10 +682,11 @@ void CefResourceManager::ContinueRequest(
     StopRequest(std::move(state));
   } else {
     // Move to the next provider if any.
-    if (IncrementProvider(state.get()))
+    if (IncrementProvider(state.get())) {
       SendRequest(std::move(state));
-    else
+    } else {
       StopRequest(std::move(state));
+    }
   }
 }
 
@@ -727,8 +753,9 @@ void CefResourceManager::DeleteProvider(ProviderEntryList::iterator& iterator,
 
   ProviderEntry* current_entry = *(iterator);
 
-  if (current_entry->deletion_pending_)
+  if (current_entry->deletion_pending_) {
     return;
+  }
 
   if (!current_entry->pending_requests_.empty()) {
     // Don't delete the provider entry until all pending requests have cleared.
@@ -739,10 +766,11 @@ void CefResourceManager::DeleteProvider(ProviderEntryList::iterator& iterator,
     for (; it != current_entry->pending_requests_.end(); ++it) {
       const scoped_refptr<Request>& request = *it;
       if (request->HasState()) {
-        if (stop)
+        if (stop) {
           request->Stop();
-        else
+        } else {
           request->Continue(nullptr);
+        }
         current_entry->provider_->OnRequestCanceled(request);
       }
     }
diff --git a/libcef_dll/wrapper/cef_scoped_temp_dir.cc b/libcef_dll/wrapper/cef_scoped_temp_dir.cc
index 9269aba40..c1318933d 100644
--- a/libcef_dll/wrapper/cef_scoped_temp_dir.cc
+++ b/libcef_dll/wrapper/cef_scoped_temp_dir.cc
@@ -10,52 +10,61 @@
 CefScopedTempDir::CefScopedTempDir() {}
 
 CefScopedTempDir::~CefScopedTempDir() {
-  if (!path_.empty() && !Delete())
+  if (!path_.empty() && !Delete()) {
     DLOG(WARNING) << "Could not delete temp dir in dtor.";
+  }
 }
 
 bool CefScopedTempDir::CreateUniqueTempDir() {
-  if (!path_.empty())
+  if (!path_.empty()) {
     return false;
+  }
 
   // This "scoped_dir" prefix is only used on Windows and serves as a template
   // for the unique name.
-  if (!CefCreateNewTempDirectory("scoped_dir", path_))
+  if (!CefCreateNewTempDirectory("scoped_dir", path_)) {
     return false;
+  }
 
   return true;
 }
 
 bool CefScopedTempDir::CreateUniqueTempDirUnderPath(
     const CefString& base_path) {
-  if (!path_.empty())
+  if (!path_.empty()) {
     return false;
+  }
 
   // If |base_path| does not exist, create it.
-  if (!CefCreateDirectory(base_path))
+  if (!CefCreateDirectory(base_path)) {
     return false;
+  }
 
   // Create a new, uniquely named directory under |base_path|.
-  if (!CefCreateTempDirectoryInDirectory(base_path, "scoped_dir_", path_))
+  if (!CefCreateTempDirectoryInDirectory(base_path, "scoped_dir_", path_)) {
     return false;
+  }
 
   return true;
 }
 
 bool CefScopedTempDir::Set(const CefString& path) {
-  if (!path_.empty())
+  if (!path_.empty()) {
     return false;
+  }
 
-  if (!CefDirectoryExists(path) && !CefCreateDirectory(path))
+  if (!CefDirectoryExists(path) && !CefCreateDirectory(path)) {
     return false;
+  }
 
   path_ = path;
   return true;
 }
 
 bool CefScopedTempDir::Delete() {
-  if (path_.empty())
+  if (path_.empty()) {
     return false;
+  }
 
   bool ret = CefDeleteFile(path_, true);
   if (ret) {
diff --git a/libcef_dll/wrapper/cef_stream_resource_handler.cc b/libcef_dll/wrapper/cef_stream_resource_handler.cc
index 62fbfb127..730398f8b 100644
--- a/libcef_dll/wrapper/cef_stream_resource_handler.cc
+++ b/libcef_dll/wrapper/cef_stream_resource_handler.cc
@@ -54,8 +54,9 @@ void CefStreamResourceHandler::GetResponseHeaders(
   response->SetStatusText(status_text_);
   response->SetMimeType(mime_type_);
 
-  if (!header_map_.empty())
+  if (!header_map_.empty()) {
     response->SetHeaderMap(header_map_);
+  }
 
   response_length = stream_ ? -1 : 0;
 }
diff --git a/libcef_dll/wrapper/cef_xml_object.cc b/libcef_dll/wrapper/cef_xml_object.cc
index c31006e26..3cdccfb37 100644
--- a/libcef_dll/wrapper/cef_xml_object.cc
+++ b/libcef_dll/wrapper/cef_xml_object.cc
@@ -24,8 +24,9 @@ class CefXmlObjectLoader {
             const CefString& URI) {
     CefRefPtr<CefXmlReader> reader(
         CefXmlReader::Create(stream, encodingType, URI));
-    if (!reader.get())
+    if (!reader.get()) {
       return false;
+    }
 
     bool ret = reader->MoveToNextNode();
     if (ret) {
@@ -170,8 +171,9 @@ bool CefXmlObject::Load(CefRefPtr<CefStreamReader> stream,
 
   CefXmlObjectLoader loader(this);
   if (!loader.Load(stream, encodingType, URI)) {
-    if (loadError)
+    if (loadError) {
       *loadError = loader.GetLoadError();
+    }
     return false;
   }
   return true;
@@ -194,8 +196,9 @@ void CefXmlObject::Append(CefRefPtr<CefXmlObject> object,
     ObjectVector children;
     object->GetChildren(children);
     ObjectVector::const_iterator it = children.begin();
-    for (; it != children.end(); ++it)
+    for (; it != children.end(); ++it) {
       AddChild((*it)->Duplicate());
+    }
   }
 
   if (object->HasAttributes()) {
@@ -203,8 +206,9 @@ void CefXmlObject::Append(CefRefPtr<CefXmlObject> object,
     object->GetAttributes(attributes);
     AttributeMap::const_iterator it = attributes.begin();
     for (; it != attributes.end(); ++it) {
-      if (overwriteAttributes || !HasAttribute(it->first))
+      if (overwriteAttributes || !HasAttribute(it->first)) {
         SetAttributeValue(it->first, it->second);
+      }
     }
   }
 }
@@ -235,8 +239,9 @@ CefString CefXmlObject::GetName() {
 
 bool CefXmlObject::SetName(const CefString& name) {
   DCHECK(!name.empty());
-  if (name.empty())
+  if (name.empty()) {
     return false;
+  }
 
   base::AutoLock lock_scope(lock_);
   name_ = name;
@@ -274,8 +279,9 @@ CefString CefXmlObject::GetValue() {
 bool CefXmlObject::SetValue(const CefString& value) {
   base::AutoLock lock_scope(lock_);
   DCHECK(children_.empty());
-  if (!children_.empty())
+  if (!children_.empty()) {
     return false;
+  }
   value_ = value;
   return true;
 }
@@ -291,8 +297,9 @@ size_t CefXmlObject::GetAttributeCount() {
 }
 
 bool CefXmlObject::HasAttribute(const CefString& name) {
-  if (name.empty())
+  if (name.empty()) {
     return false;
+  }
 
   base::AutoLock lock_scope(lock_);
   AttributeMap::const_iterator it = attributes_.find(name);
@@ -305,8 +312,9 @@ CefString CefXmlObject::GetAttributeValue(const CefString& name) {
   if (!name.empty()) {
     base::AutoLock lock_scope(lock_);
     AttributeMap::const_iterator it = attributes_.find(name);
-    if (it != attributes_.end())
+    if (it != attributes_.end()) {
       value = it->second;
+    }
   }
   return value;
 }
@@ -314,8 +322,9 @@ CefString CefXmlObject::GetAttributeValue(const CefString& name) {
 bool CefXmlObject::SetAttributeValue(const CefString& name,
                                      const CefString& value) {
   DCHECK(!name.empty());
-  if (name.empty())
+  if (name.empty()) {
     return false;
+  }
 
   base::AutoLock lock_scope(lock_);
   AttributeMap::iterator it = attributes_.find(name);
@@ -354,21 +363,24 @@ bool CefXmlObject::HasChild(CefRefPtr<CefXmlObject> child) {
   base::AutoLock lock_scope(lock_);
   ObjectVector::const_iterator it = children_.begin();
   for (; it != children_.end(); ++it) {
-    if ((*it).get() == child.get())
+    if ((*it).get() == child.get()) {
       return true;
+    }
   }
   return false;
 }
 
 bool CefXmlObject::AddChild(CefRefPtr<CefXmlObject> child) {
   DCHECK(child.get());
-  if (!child.get())
+  if (!child.get()) {
     return false;
+  }
 
   CefRefPtr<CefXmlObject> parent = child->GetParent();
   DCHECK(!parent);
-  if (parent)
+  if (parent) {
     return false;
+  }
 
   base::AutoLock lock_scope(lock_);
 
@@ -401,21 +413,24 @@ size_t CefXmlObject::GetChildren(ObjectVector& children) {
 void CefXmlObject::ClearChildren() {
   base::AutoLock lock_scope(lock_);
   ObjectVector::iterator it = children_.begin();
-  for (; it != children_.end(); ++it)
+  for (; it != children_.end(); ++it) {
     (*it)->SetParent(nullptr);
+  }
   children_.clear();
 }
 
 CefRefPtr<CefXmlObject> CefXmlObject::FindChild(const CefString& name) {
   DCHECK(!name.empty());
-  if (name.empty())
+  if (name.empty()) {
     return nullptr;
+  }
 
   base::AutoLock lock_scope(lock_);
   ObjectVector::const_iterator it = children_.begin();
   for (; it != children_.end(); ++it) {
-    if ((*it)->GetName() == name)
+    if ((*it)->GetName() == name) {
       return (*it);
+    }
   }
   return nullptr;
 }
@@ -423,8 +438,9 @@ CefRefPtr<CefXmlObject> CefXmlObject::FindChild(const CefString& name) {
 size_t CefXmlObject::FindChildren(const CefString& name,
                                   ObjectVector& children) {
   DCHECK(!name.empty());
-  if (name.empty())
+  if (name.empty()) {
     return 0;
+  }
 
   size_t ct = 0;
 
diff --git a/libcef_dll/wrapper/cef_zip_archive.cc b/libcef_dll/wrapper/cef_zip_archive.cc
index b892f2d3d..3ebff15b0 100644
--- a/libcef_dll/wrapper/cef_zip_archive.cc
+++ b/libcef_dll/wrapper/cef_zip_archive.cc
@@ -77,11 +77,13 @@ size_t CefZipArchive::Load(CefRefPtr<CefStreamReader> stream,
   base::AutoLock lock_scope(lock_);
 
   CefRefPtr<CefZipReader> reader(CefZipReader::Create(stream));
-  if (!reader.get())
+  if (!reader.get()) {
     return 0;
+  }
 
-  if (!reader->MoveToFirstFile())
+  if (!reader->MoveToFirstFile()) {
     return 0;
+  }
 
   FileMap::iterator it;
   size_t count = 0;
@@ -93,22 +95,25 @@ size_t CefZipArchive::Load(CefRefPtr<CefStreamReader> stream,
       continue;
     }
 
-    if (!reader->OpenFile(password))
+    if (!reader->OpenFile(password)) {
       break;
+    }
 
     const CefString& name = ToLower(reader->GetFileName());
 
     it = contents_.find(name);
     if (it != contents_.end()) {
-      if (overwriteExisting)
+      if (overwriteExisting) {
         contents_.erase(it);
-      else  // Skip files that already exist.
+      } else {  // Skip files that already exist.
         continue;
+      }
     }
 
     CefRefPtr<CefZipFile> contents = new CefZipFile();
-    if (!contents->Initialize(size))
+    if (!contents->Initialize(size)) {
       continue;
+    }
     unsigned char* data = contents->data();
     size_t offset = 0;
 
@@ -149,8 +154,9 @@ CefRefPtr<CefZipArchive::File> CefZipArchive::GetFile(
     const CefString& fileName) const {
   base::AutoLock lock_scope(lock_);
   FileMap::const_iterator it = contents_.find(ToLower(fileName));
-  if (it != contents_.end())
+  if (it != contents_.end()) {
     return it->second;
+  }
   return nullptr;
 }
 
diff --git a/tests/cefclient/browser/binding_test.cc b/tests/cefclient/browser/binding_test.cc
index 3505eed15..0dfdc7752 100644
--- a/tests/cefclient/browser/binding_test.cc
+++ b/tests/cefclient/browser/binding_test.cc
@@ -31,8 +31,9 @@ class Handler : public CefMessageRouterBrowserSide::Handler {
                        CefRefPtr<Callback> callback) override {
     // Only handle messages from the test URL.
     const std::string& url = frame->GetURL();
-    if (!test_runner::IsTestURL(url, kTestUrlPath))
+    if (!test_runner::IsTestURL(url, kTestUrlPath)) {
       return false;
+    }
 
     const std::string& message_name = request;
     if (message_name.find(kTestMessageName) == 0) {
diff --git a/tests/cefclient/browser/browser_window_osr_gtk.cc b/tests/cefclient/browser/browser_window_osr_gtk.cc
index 8878a6d9d..db5ce52f3 100644
--- a/tests/cefclient/browser/browser_window_osr_gtk.cc
+++ b/tests/cefclient/browser/browser_window_osr_gtk.cc
@@ -35,20 +35,27 @@ std::vector<BrowserWindowOsrGtk*> g_browser_windows;
 
 int GetCefStateModifiers(guint state) {
   int modifiers = 0;
-  if (state & GDK_SHIFT_MASK)
+  if (state & GDK_SHIFT_MASK) {
     modifiers |= EVENTFLAG_SHIFT_DOWN;
-  if (state & GDK_LOCK_MASK)
+  }
+  if (state & GDK_LOCK_MASK) {
     modifiers |= EVENTFLAG_CAPS_LOCK_ON;
-  if (state & GDK_CONTROL_MASK)
+  }
+  if (state & GDK_CONTROL_MASK) {
     modifiers |= EVENTFLAG_CONTROL_DOWN;
-  if (state & GDK_MOD1_MASK)
+  }
+  if (state & GDK_MOD1_MASK) {
     modifiers |= EVENTFLAG_ALT_DOWN;
-  if (state & GDK_BUTTON1_MASK)
+  }
+  if (state & GDK_BUTTON1_MASK) {
     modifiers |= EVENTFLAG_LEFT_MOUSE_BUTTON;
-  if (state & GDK_BUTTON2_MASK)
+  }
+  if (state & GDK_BUTTON2_MASK) {
     modifiers |= EVENTFLAG_MIDDLE_MOUSE_BUTTON;
-  if (state & GDK_BUTTON3_MASK)
+  }
+  if (state & GDK_BUTTON3_MASK) {
     modifiers |= EVENTFLAG_RIGHT_MOUSE_BUTTON;
+  }
   return modifiers;
 }
 
@@ -787,13 +794,15 @@ KeyboardCode GdkEventToWindowsKeyCode(const GdkEventKey* event) {
   // key and a caps-lock key, GTK doesn't swap their
   // |event->hardware_keycode| values but swap their |event->keyval| values.
   KeyboardCode windows_key_code = KeyboardCodeFromXKeysym(event->keyval);
-  if (windows_key_code)
+  if (windows_key_code) {
     return windows_key_code;
+  }
 
   if (event->hardware_keycode < std::size(kHardwareCodeToGDKKeyval)) {
     int keyval = kHardwareCodeToGDKKeyval[event->hardware_keycode];
-    if (keyval)
+    if (keyval) {
       return KeyboardCodeFromXKeysym(keyval);
+    }
   }
 
   // This key is one that keyboard-layout drivers cannot change.
@@ -868,14 +877,18 @@ CefBrowserHost::DragOperationsMask GetDragOperationsMask(
     GdkDragContext* drag_context) {
   int allowed_ops = DRAG_OPERATION_NONE;
   GdkDragAction drag_action = gdk_drag_context_get_actions(drag_context);
-  if (drag_action & GDK_ACTION_COPY)
+  if (drag_action & GDK_ACTION_COPY) {
     allowed_ops |= DRAG_OPERATION_COPY;
-  if (drag_action & GDK_ACTION_MOVE)
+  }
+  if (drag_action & GDK_ACTION_MOVE) {
     allowed_ops |= DRAG_OPERATION_MOVE;
-  if (drag_action & GDK_ACTION_LINK)
+  }
+  if (drag_action & GDK_ACTION_LINK) {
     allowed_ops |= DRAG_OPERATION_LINK;
-  if (drag_action & GDK_ACTION_PRIVATE)
+  }
+  if (drag_action & GDK_ACTION_PRIVATE) {
     allowed_ops |= DRAG_OPERATION_PRIVATE;
+  }
   return static_cast<CefBrowserHost::DragOperationsMask>(allowed_ops);
 }
 
@@ -892,8 +905,9 @@ class ScopedGLContext {
   }
 
   virtual ~ScopedGLContext() {
-    if (swap_buffers_ && is_valid_)
+    if (swap_buffers_ && is_valid_) {
       glFlush();
+    }
   }
 
   bool IsValid() const { return is_valid_; }
@@ -1023,8 +1037,9 @@ void BrowserWindowOsrGtk::Show() {
 void BrowserWindowOsrGtk::Hide() {
   REQUIRE_MAIN_THREAD();
 
-  if (!browser_)
+  if (!browser_) {
     return;
+  }
 
   // Remove focus from the browser.
   browser_->GetHost()->SetFocus(false);
@@ -1052,12 +1067,14 @@ void BrowserWindowOsrGtk::SetDeviceScaleFactor(float device_scale_factor) {
   REQUIRE_MAIN_THREAD();
   {
     base::AutoLock lock_scope(lock_);
-    if (device_scale_factor == device_scale_factor_)
+    if (device_scale_factor == device_scale_factor_) {
       return;
+    }
 
     // Apply some sanity checks.
-    if (device_scale_factor < 1.0f || device_scale_factor > 4.0f)
+    if (device_scale_factor < 1.0f || device_scale_factor > 4.0f) {
       return;
+    }
 
     device_scale_factor_ = device_scale_factor;
   }
@@ -1129,11 +1146,13 @@ void BrowserWindowOsrGtk::GetViewRect(CefRefPtr<CefBrowser> browser,
   GtkAllocation allocation;
   gtk_widget_get_allocation(glarea_, &allocation);
   rect.width = DeviceToLogical(allocation.width, device_scale_factor);
-  if (rect.width == 0)
+  if (rect.width == 0) {
     rect.width = 1;
+  }
   rect.height = DeviceToLogical(allocation.height, device_scale_factor);
-  if (rect.height == 0)
+  if (rect.height == 0) {
     rect.height = 1;
+  }
 }
 
 bool BrowserWindowOsrGtk::GetScreenPoint(CefRefPtr<CefBrowser> browser,
@@ -1223,12 +1242,14 @@ void BrowserWindowOsrGtk::OnPaint(CefRefPtr<CefBrowser> browser,
     return;
   }
 
-  if (!gl_enabled_)
+  if (!gl_enabled_) {
     EnableGL();
+  }
 
   ScopedGLContext scoped_gl_context(glarea_, true);
-  if (!scoped_gl_context.IsValid())
+  if (!scoped_gl_context.IsValid()) {
     return;
+  }
 
   renderer_.OnPaint(browser, type, dirtyRects, buffer, width, height);
   if (type == PET_VIEW && !renderer_.popup_rect().IsEmpty()) {
@@ -1397,8 +1418,9 @@ gint BrowserWindowOsrGtk::ClickEvent(GtkWidget* widget,
                                      BrowserWindowOsrGtk* self) {
   REQUIRE_MAIN_THREAD();
 
-  if (!self->browser_.get())
+  if (!self->browser_.get()) {
     return TRUE;
+  }
 
   CefRefPtr<CefBrowserHost> host = self->browser_->GetHost();
 
@@ -1467,8 +1489,9 @@ gint BrowserWindowOsrGtk::KeyEvent(GtkWidget* widget,
                                    BrowserWindowOsrGtk* self) {
   REQUIRE_MAIN_THREAD();
 
-  if (!self->browser_.get())
+  if (!self->browser_.get()) {
     return TRUE;
+  }
 
   CefRefPtr<CefBrowserHost> host = self->browser_->GetHost();
 
@@ -1481,10 +1504,12 @@ gint BrowserWindowOsrGtk::KeyEvent(GtkWidget* widget,
   key_event.native_key_code = event->hardware_keycode;
 
   key_event.modifiers = GetCefStateModifiers(event->state);
-  if (event->keyval >= GDK_KP_Space && event->keyval <= GDK_KP_9)
+  if (event->keyval >= GDK_KP_Space && event->keyval <= GDK_KP_9) {
     key_event.modifiers |= EVENTFLAG_IS_KEY_PAD;
-  if (key_event.modifiers & EVENTFLAG_ALT_DOWN)
+  }
+  if (key_event.modifiers & EVENTFLAG_ALT_DOWN) {
     key_event.is_system_key = true;
+  }
 
   if (windows_key_code == VKEY_RETURN) {
     // We need to treat the enter key as a key press of character \r.  This
@@ -1521,8 +1546,9 @@ gint BrowserWindowOsrGtk::KeyEvent(GtkWidget* widget,
 gint BrowserWindowOsrGtk::MoveEvent(GtkWidget* widget,
                                     GdkEventMotion* event,
                                     BrowserWindowOsrGtk* self) {
-  if (!self->browser_.get())
+  if (!self->browser_.get()) {
     return TRUE;
+  }
 
   CefRefPtr<CefBrowserHost> host = self->browser_->GetHost();
 
@@ -1578,8 +1604,9 @@ gint BrowserWindowOsrGtk::ScrollEvent(GtkWidget* widget,
                                       BrowserWindowOsrGtk* self) {
   REQUIRE_MAIN_THREAD();
 
-  if (!self->browser_.get())
+  if (!self->browser_.get()) {
     return TRUE;
+  }
 
   CefRefPtr<CefBrowserHost> host = self->browser_->GetHost();
 
@@ -1626,8 +1653,9 @@ gint BrowserWindowOsrGtk::FocusEvent(GtkWidget* widget,
                                      GdkEventFocus* event,
                                      BrowserWindowOsrGtk* self) {
   // May be called on the main thread and the UI thread.
-  if (self->browser_.get())
+  if (self->browser_.get()) {
     self->browser_->GetHost()->SetFocus(event->in == TRUE);
+  }
   return TRUE;
 }
 
@@ -1637,8 +1665,9 @@ gboolean BrowserWindowOsrGtk::TouchEvent(GtkWidget* widget,
                                          BrowserWindowOsrGtk* self) {
   REQUIRE_MAIN_THREAD();
 
-  if (!self->browser_.get())
+  if (!self->browser_.get()) {
     return TRUE;
+  }
 
   CefRefPtr<CefBrowserHost> host = self->browser_->GetHost();
 
@@ -1701,12 +1730,14 @@ void BrowserWindowOsrGtk::ApplyPopupOffset(int& x, int& y) const {
 void BrowserWindowOsrGtk::EnableGL() {
   CEF_REQUIRE_UI_THREAD();
 
-  if (gl_enabled_)
+  if (gl_enabled_) {
     return;
+  }
 
   ScopedGLContext scoped_gl_context(glarea_, false);
-  if (!scoped_gl_context.IsValid())
+  if (!scoped_gl_context.IsValid()) {
     return;
+  }
 
   renderer_.Initialize();
 
@@ -1716,12 +1747,14 @@ void BrowserWindowOsrGtk::EnableGL() {
 void BrowserWindowOsrGtk::DisableGL() {
   CEF_REQUIRE_UI_THREAD();
 
-  if (!gl_enabled_)
+  if (!gl_enabled_) {
     return;
+  }
 
   ScopedGLContext scoped_gl_context(glarea_, false);
-  if (!scoped_gl_context.IsValid())
+  if (!scoped_gl_context.IsValid()) {
     return;
+  }
 
   renderer_.Cleanup();
 
diff --git a/tests/cefclient/browser/browser_window_osr_mac.mm b/tests/cefclient/browser/browser_window_osr_mac.mm
index c44be51a4..b7984f465 100644
--- a/tests/cefclient/browser/browser_window_osr_mac.mm
+++ b/tests/cefclient/browser/browser_window_osr_mac.mm
@@ -69,8 +69,9 @@ class ScopedGLContext {
   }
   ~ScopedGLContext() {
     [NSOpenGLContext clearCurrentContext];
-    if (swap_buffers_)
+    if (swap_buffers_) {
       [context_ flushBuffer];
+    }
   }
 
  private:
@@ -144,20 +145,23 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
 - (void)detach {
   renderer_ = nullptr;
   browser_window_ = nullptr;
-  if (text_input_client_)
+  if (text_input_client_) {
     [text_input_client_ detach];
+  }
 }
 
 - (CefRefPtr<CefBrowser>)getBrowser {
-  if (browser_window_)
+  if (browser_window_) {
     return browser_window_->GetBrowser();
+  }
   return nullptr;
 }
 
 - (void)setFrame:(NSRect)frameRect {
   CefRefPtr<CefBrowser> browser = [self getBrowser];
-  if (!browser.get())
+  if (!browser.get()) {
     return;
+  }
 
   [super setFrame:frameRect];
   browser->GetHost()->WasResized();
@@ -167,8 +171,9 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
                 button:(CefBrowserHost::MouseButtonType)type
                   isUp:(bool)isUp {
   CefRefPtr<CefBrowser> browser = [self getBrowser];
-  if (!browser.get())
+  if (!browser.get()) {
     return;
+  }
 
   CefMouseEvent mouseEvent;
   [self getMouseEvent:mouseEvent forEvent:event];
@@ -232,8 +237,9 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
 
 - (void)mouseMoved:(NSEvent*)event {
   CefRefPtr<CefBrowser> browser = [self getBrowser];
-  if (!browser.get())
+  if (!browser.get()) {
     return;
+  }
 
   if (rotating_) {
     // Apply rotation effect.
@@ -270,8 +276,9 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
 
 - (void)mouseExited:(NSEvent*)event {
   CefRefPtr<CefBrowser> browser = [self getBrowser];
-  if (!browser.get())
+  if (!browser.get()) {
     return;
+  }
 
   CefMouseEvent mouseEvent;
   [self getMouseEvent:mouseEvent forEvent:event];
@@ -281,8 +288,9 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
 
 - (void)keyDown:(NSEvent*)event {
   CefRefPtr<CefBrowser> browser = [self getBrowser];
-  if (!browser.get() || !text_input_context_osr_mac_)
+  if (!browser.get() || !text_input_context_osr_mac_) {
     return;
+  }
 
   if ([event type] != NSEventTypeFlagsChanged) {
     if (text_input_client_) {
@@ -300,8 +308,9 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
   }
 
   // Check for Caps lock and Toggle Touch Emulation
-  if (client::MainContext::Get()->TouchEventsEnabled())
+  if (client::MainContext::Get()->TouchEventsEnabled()) {
     [self toggleTouchEmulation:event];
+  }
 }
 
 // OSX does not have touch screens, so we emulate it by mapping multitouch
@@ -312,10 +321,11 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
   if ([event type] == NSEventTypeFlagsChanged && [event keyCode] == 0x39) {
     NSUInteger flags = [event modifierFlags];
     BOOL touch_enabled = flags & NSEventModifierFlagCapsLock ? YES : NO;
-    if (touch_enabled)
+    if (touch_enabled) {
       self.allowedTouchTypes |= NSTouchTypeMaskDirect;
-    else
+    } else {
       self.allowedTouchTypes &= ~NSTouchTypeMaskDirect;
+    }
   }
 }
 
@@ -409,8 +419,9 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
 
 - (void)keyUp:(NSEvent*)event {
   CefRefPtr<CefBrowser> browser = [self getBrowser];
-  if (!browser.get())
+  if (!browser.get()) {
     return;
+  }
 
   CefKeyEvent keyEvent;
   [self getKeyEvent:keyEvent forEvent:event];
@@ -420,16 +431,18 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
 }
 
 - (void)flagsChanged:(NSEvent*)event {
-  if ([self isKeyUpEvent:event])
+  if ([self isKeyUpEvent:event]) {
     [self keyUp:event];
-  else
+  } else {
     [self keyDown:event];
+  }
 }
 
 - (void)shortCircuitScrollWheelEvent:(NSEvent*)event {
   if ([event phase] != NSEventPhaseEnded &&
-      [event phase] != NSEventPhaseCancelled)
+      [event phase] != NSEventPhaseCancelled) {
     return;
+  }
 
   [self sendScrollWheelEvet:event];
 
@@ -459,8 +472,9 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
 
 - (void)sendScrollWheelEvet:(NSEvent*)event {
   CefRefPtr<CefBrowser> browser = [self getBrowser];
-  if (!browser.get())
+  if (!browser.get()) {
     return;
+  }
 
   CGEventRef cgEvent = [event CGEvent];
   DCHECK(cgEvent);
@@ -508,44 +522,51 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
 
 - (void)undo:(id)sender {
   CefRefPtr<CefBrowser> browser = [self getBrowser];
-  if (browser.get())
+  if (browser.get()) {
     browser->GetFocusedFrame()->Undo();
+  }
 }
 
 - (void)redo:(id)sender {
   CefRefPtr<CefBrowser> browser = [self getBrowser];
-  if (browser.get())
+  if (browser.get()) {
     browser->GetFocusedFrame()->Redo();
+  }
 }
 
 - (void)cut:(id)sender {
   CefRefPtr<CefBrowser> browser = [self getBrowser];
-  if (browser.get())
+  if (browser.get()) {
     browser->GetFocusedFrame()->Cut();
+  }
 }
 
 - (void)copy:(id)sender {
   CefRefPtr<CefBrowser> browser = [self getBrowser];
-  if (browser.get())
+  if (browser.get()) {
     browser->GetFocusedFrame()->Copy();
+  }
 }
 
 - (void)paste:(id)sender {
   CefRefPtr<CefBrowser> browser = [self getBrowser];
-  if (browser.get())
+  if (browser.get()) {
     browser->GetFocusedFrame()->Paste();
+  }
 }
 
 - (void)delete:(id)sender {
   CefRefPtr<CefBrowser> browser = [self getBrowser];
-  if (browser.get())
+  if (browser.get()) {
     browser->GetFocusedFrame()->Delete();
+  }
 }
 
 - (void)selectAll:(id)sender {
   CefRefPtr<CefBrowser> browser = [self getBrowser];
-  if (browser.get())
+  if (browser.get()) {
     browser->GetFocusedFrame()->SelectAll();
+  }
 }
 
 - (NSPoint)getClickPointForEvent:(NSEvent*)event {
@@ -561,12 +582,14 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
 - (void)getKeyEvent:(CefKeyEvent&)keyEvent forEvent:(NSEvent*)event {
   if ([event type] == NSEventTypeKeyDown || [event type] == NSEventTypeKeyUp) {
     NSString* s = [event characters];
-    if ([s length] > 0)
+    if ([s length] > 0) {
       keyEvent.character = [s characterAtIndex:0];
+    }
 
     s = [event charactersIgnoringModifiers];
-    if ([s length] > 0)
+    if ([s length] > 0) {
       keyEvent.unmodified_character = [s characterAtIndex:0];
+    }
   }
 
   if ([event type] == NSEventTypeFlagsChanged) {
@@ -605,8 +628,9 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
 
   int device_x = point.x;
   int device_y = point.y;
-  if ([self isOverPopupWidgetX:device_x andY:device_y])
+  if ([self isOverPopupWidgetX:device_x andY:device_y]) {
     [self applyPopupOffsetToX:device_x andY:device_y];
+  }
 
   // Convert to browser view coordinates.
   mouseEvent.x = client::DeviceToLogical(device_x, device_scale_factor);
@@ -636,22 +660,28 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
 - (int)getModifiersForEvent:(NSEvent*)event {
   int modifiers = 0;
 
-  if ([event modifierFlags] & NSEventModifierFlagControl)
+  if ([event modifierFlags] & NSEventModifierFlagControl) {
     modifiers |= EVENTFLAG_CONTROL_DOWN;
-  if ([event modifierFlags] & NSEventModifierFlagShift)
+  }
+  if ([event modifierFlags] & NSEventModifierFlagShift) {
     modifiers |= EVENTFLAG_SHIFT_DOWN;
-  if ([event modifierFlags] & NSEventModifierFlagOption)
+  }
+  if ([event modifierFlags] & NSEventModifierFlagOption) {
     modifiers |= EVENTFLAG_ALT_DOWN;
-  if ([event modifierFlags] & NSEventModifierFlagCommand)
+  }
+  if ([event modifierFlags] & NSEventModifierFlagCommand) {
     modifiers |= EVENTFLAG_COMMAND_DOWN;
-  if ([event modifierFlags] & NSEventModifierFlagCapsLock)
+  }
+  if ([event modifierFlags] & NSEventModifierFlagCapsLock) {
     modifiers |= EVENTFLAG_CAPS_LOCK_ON;
+  }
 
   if ([event type] == NSEventTypeKeyUp || [event type] == NSEventTypeKeyDown ||
       [event type] == NSEventTypeFlagsChanged) {
     // Only perform this check for key events
-    if ([self isKeyPadEvent:event])
+    if ([self isKeyPadEvent:event]) {
       modifiers |= EVENTFLAG_IS_KEY_PAD;
+    }
   }
 
   // OS X does not have a modifier for NumLock, so I'm not entirely sure how to
@@ -684,8 +714,9 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
 }
 
 - (BOOL)isKeyUpEvent:(NSEvent*)event {
-  if ([event type] != NSEventTypeFlagsChanged)
+  if ([event type] != NSEventTypeFlagsChanged) {
     return [event type] == NSEventTypeKeyUp;
+  }
 
   // FIXME: This logic fails if the user presses both Shift keys at once, for
   // example: we treat releasing one of them as keyDown.
@@ -716,8 +747,9 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
 }
 
 - (BOOL)isKeyPadEvent:(NSEvent*)event {
-  if ([event modifierFlags] & NSEventModifierFlagNumericPad)
+  if ([event modifierFlags] & NSEventModifierFlagNumericPad) {
     return true;
+  }
 
   switch ([event keyCode]) {
     case 71:  // Clear
@@ -766,8 +798,9 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
   }
 
   // The Invalidate below fixes flicker when resizing.
-  if ([self inLiveResize] && browser.get())
+  if ([self inLiveResize] && browser.get()) {
     browser->GetHost()->Invalidate(PET_VIEW);
+  }
 }
 
 // Drag and drop
@@ -833,26 +866,31 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
 }
 
 - (NSArray*)namesOfPromisedFilesDroppedAtDestination:(NSURL*)dropDest {
-  if (![dropDest isFileURL])
+  if (![dropDest isFileURL]) {
     return nil;
+  }
 
-  if (!current_drag_data_)
+  if (!current_drag_data_) {
     return nil;
+  }
 
   size_t expected_size = current_drag_data_->GetFileContents(nullptr);
-  if (expected_size == 0)
+  if (expected_size == 0) {
     return nil;
+  }
 
   std::string path = [[dropDest path] UTF8String];
   path.append("/");
   path.append(current_drag_data_->GetFileName().ToString());
 
   CefRefPtr<CefStreamWriter> writer = CefStreamWriter::CreateForFile(path);
-  if (!writer)
+  if (!writer) {
     return nil;
+  }
 
-  if (current_drag_data_->GetFileContents(writer) != expected_size)
+  if (current_drag_data_->GetFileContents(writer) != expected_size) {
     return nil;
+  }
 
   return @[ [NSString stringWithUTF8String:path.c_str()] ];
 }
@@ -861,11 +899,13 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
              endedAt:(NSPoint)screenPoint
            operation:(NSDragOperation)operation {
   CefRefPtr<CefBrowser> browser = [self getBrowser];
-  if (!browser.get())
+  if (!browser.get()) {
     return;
+  }
 
-  if (operation == (NSDragOperationMove | NSDragOperationCopy))
+  if (operation == (NSDragOperationMove | NSDragOperationCopy)) {
     operation &= ~NSDragOperationMove;
+  }
 
   NSPoint windowPoint = [[self window] convertScreenToBase:screenPoint];
   NSPoint pt = [self flipWindowPointToView:windowPoint];
@@ -880,8 +920,9 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
 
 - (NSDragOperation)draggingEntered:(id<NSDraggingInfo>)info {
   CefRefPtr<CefBrowser> browser = [self getBrowser];
-  if (!browser.get())
+  if (!browser.get()) {
     return NSDragOperationNone;
+  }
 
   CefRefPtr<CefDragData> drag_data;
   if (!current_drag_data_) {
@@ -908,8 +949,9 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
 
 - (void)draggingExited:(id<NSDraggingInfo>)sender {
   CefRefPtr<CefBrowser> browser = [self getBrowser];
-  if (browser.get())
+  if (browser.get()) {
     browser->GetHost()->DragTargetDragLeave();
+  }
 }
 
 - (BOOL)prepareForDragOperation:(id<NSDraggingInfo>)info {
@@ -918,8 +960,9 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
 
 - (BOOL)performDragOperation:(id<NSDraggingInfo>)info {
   CefRefPtr<CefBrowser> browser = [self getBrowser];
-  if (!browser.get())
+  if (!browser.get()) {
     return NO;
+  }
 
   CefMouseEvent mouseEvent;
   [self getMouseEvent:mouseEvent forDragInfo:info];
@@ -931,8 +974,9 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
 
 - (NSDragOperation)draggingUpdated:(id<NSDraggingInfo>)info {
   CefRefPtr<CefBrowser> browser = [self getBrowser];
-  if (!browser.get())
+  if (!browser.get()) {
     return NSDragOperationNone;
+  }
 
   CefMouseEvent mouseEvent;
   [self getMouseEvent:mouseEvent forDragInfo:info];
@@ -1001,15 +1045,17 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
 
 // NSAccessibility Protocol implementation.
 - (BOOL)accessibilityIsIgnored {
-  if (!accessibility_helper_)
+  if (!accessibility_helper_) {
     return YES;
-  else
+  } else {
     return NO;
+  }
 }
 
 - (id)accessibilityAttributeValue:(NSString*)attribute {
-  if (!accessibility_helper_)
+  if (!accessibility_helper_) {
     return [super accessibilityAttributeValue:attribute];
+  }
   if ([attribute isEqualToString:NSAccessibilityRoleAttribute]) {
     return NSAccessibilityGroupRole;
   } else if ([attribute isEqualToString:NSAccessibilityDescriptionAttribute]) {
@@ -1156,18 +1202,21 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
 - (void)resetDeviceScaleFactor {
   float device_scale_factor = 1.0f;
   NSWindow* window = [self window];
-  if (window)
+  if (window) {
     device_scale_factor = [window backingScaleFactor];
+  }
   [self setDeviceScaleFactor:device_scale_factor];
 }
 
 - (void)setDeviceScaleFactor:(float)device_scale_factor {
-  if (device_scale_factor == device_scale_factor_)
+  if (device_scale_factor == device_scale_factor_) {
     return;
+  }
 
   // Apply some sanity checks.
-  if (device_scale_factor < 1.0f || device_scale_factor > 4.0f)
+  if (device_scale_factor < 1.0f || device_scale_factor > 4.0f) {
     return;
+  }
 
   device_scale_factor_ = device_scale_factor;
 
@@ -1185,8 +1234,9 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
 - (void)viewDidChangeBackingProperties {
   const CGFloat device_scale_factor = [self getDeviceScaleFactor];
 
-  if (device_scale_factor == device_scale_factor_)
+  if (device_scale_factor == device_scale_factor_) {
     return;
+  }
 
   CefRefPtr<CefBrowser> browser = [self getBrowser];
   if (browser) {
@@ -1239,8 +1289,9 @@ NSPoint ConvertPointFromWindowToScreen(NSWindow* window, NSPoint point) {
 
 - (void)ChangeCompositionRange:(CefRange)range
               character_bounds:(const CefRenderHandler::RectList&)bounds {
-  if (text_input_client_)
+  if (text_input_client_) {
     [text_input_client_ ChangeCompositionRange:range character_bounds:bounds];
+  }
 }
 
 - (void)UpdateAccessibilityTree:(CefRefPtr<CefValue>)value {
@@ -1439,8 +1490,9 @@ void BrowserWindowOsrMacImpl::Show() {
 void BrowserWindowOsrMacImpl::Hide() {
   REQUIRE_MAIN_THREAD();
 
-  if (!browser_window_.browser_.get())
+  if (!browser_window_.browser_.get()) {
     return;
+  }
 
   // Remove focus from the browser.
   browser_window_.browser_->GetHost()->SetFocus(false);
@@ -1462,20 +1514,23 @@ void BrowserWindowOsrMacImpl::SetBounds(int x,
 
 void BrowserWindowOsrMacImpl::SetFocus(bool focus) {
   REQUIRE_MAIN_THREAD();
-  if (native_browser_view_)
+  if (native_browser_view_) {
     [native_browser_view_.window makeFirstResponder:native_browser_view_];
+  }
 }
 
 void BrowserWindowOsrMacImpl::SetDeviceScaleFactor(float device_scale_factor) {
   REQUIRE_MAIN_THREAD();
-  if (native_browser_view_)
+  if (native_browser_view_) {
     [native_browser_view_ setDeviceScaleFactor:device_scale_factor];
+  }
 }
 
 float BrowserWindowOsrMacImpl::GetDeviceScaleFactor() const {
   REQUIRE_MAIN_THREAD();
-  if (native_browser_view_)
+  if (native_browser_view_) {
     return [native_browser_view_ getDeviceScaleFactor];
+  }
   return 1.0f;
 }
 
@@ -1526,11 +1581,13 @@ void BrowserWindowOsrMacImpl::GetViewRect(CefRefPtr<CefBrowser> browser,
 
   // Convert to browser view coordinates.
   rect.width = DeviceToLogical(bounds.size.width, device_scale_factor);
-  if (rect.width == 0)
+  if (rect.width == 0) {
     rect.width = 1;
+  }
   rect.height = DeviceToLogical(bounds.size.height, device_scale_factor);
-  if (rect.height == 0)
+  if (rect.height == 0) {
     rect.height = 1;
+  }
 }
 
 bool BrowserWindowOsrMacImpl::GetScreenPoint(CefRefPtr<CefBrowser> browser,
@@ -1541,8 +1598,9 @@ bool BrowserWindowOsrMacImpl::GetScreenPoint(CefRefPtr<CefBrowser> browser,
   CEF_REQUIRE_UI_THREAD();
   REQUIRE_MAIN_THREAD();
 
-  if (!native_browser_view_)
+  if (!native_browser_view_) {
     return false;
+  }
 
   const float device_scale_factor = [native_browser_view_ getDeviceScaleFactor];
 
@@ -1573,8 +1631,9 @@ bool BrowserWindowOsrMacImpl::GetScreenInfo(CefRefPtr<CefBrowser> browser,
   CEF_REQUIRE_UI_THREAD();
   REQUIRE_MAIN_THREAD();
 
-  if (!native_browser_view_)
+  if (!native_browser_view_) {
     return false;
+  }
 
   CefRect view_rect;
   GetViewRect(browser, view_rect);
@@ -1594,8 +1653,9 @@ void BrowserWindowOsrMacImpl::OnPopupShow(CefRefPtr<CefBrowser> browser,
   CEF_REQUIRE_UI_THREAD();
   REQUIRE_MAIN_THREAD();
 
-  if (!native_browser_view_)
+  if (!native_browser_view_) {
     return;
+  }
 
   if (!show) {
     renderer_.ClearPopupRects();
@@ -1609,8 +1669,9 @@ void BrowserWindowOsrMacImpl::OnPopupSize(CefRefPtr<CefBrowser> browser,
   CEF_REQUIRE_UI_THREAD();
   REQUIRE_MAIN_THREAD();
 
-  if (!native_browser_view_)
+  if (!native_browser_view_) {
     return;
+  }
 
   const float device_scale_factor = [native_browser_view_ getDeviceScaleFactor];
 
@@ -1630,8 +1691,9 @@ void BrowserWindowOsrMacImpl::OnPaint(
   CEF_REQUIRE_UI_THREAD();
   REQUIRE_MAIN_THREAD();
 
-  if (!native_browser_view_)
+  if (!native_browser_view_) {
     return;
+  }
 
   if (width <= 2 && height <= 2) {
     // Ignore really small buffer sizes while the widget is starting up.
@@ -1674,8 +1736,9 @@ bool BrowserWindowOsrMacImpl::StartDragging(
   CEF_REQUIRE_UI_THREAD();
   REQUIRE_MAIN_THREAD();
 
-  if (!native_browser_view_)
+  if (!native_browser_view_) {
     return false;
+  }
 
   static float device_scale_factor =
       [native_browser_view_ getDeviceScaleFactor];
@@ -1702,8 +1765,9 @@ void BrowserWindowOsrMacImpl::UpdateDragCursor(
   CEF_REQUIRE_UI_THREAD();
   REQUIRE_MAIN_THREAD();
 
-  if (native_browser_view_)
+  if (native_browser_view_) {
     [native_browser_view_ setCurrentDragOp:operation];
+  }
 }
 
 void BrowserWindowOsrMacImpl::OnImeCompositionRangeChanged(
diff --git a/tests/cefclient/browser/browser_window_osr_win.cc b/tests/cefclient/browser/browser_window_osr_win.cc
index c2835b28f..3a9e3c634 100644
--- a/tests/cefclient/browser/browser_window_osr_win.cc
+++ b/tests/cefclient/browser/browser_window_osr_win.cc
@@ -57,46 +57,54 @@ void BrowserWindowOsrWin::ShowPopup(ClientWindowHandle parent_handle,
                                     size_t width,
                                     size_t height) {
   REQUIRE_MAIN_THREAD();
-  if (osr_window_)
+  if (osr_window_) {
     osr_window_->ShowPopup(parent_handle, x, y, width, height);
+  }
 }
 
 void BrowserWindowOsrWin::Show() {
   REQUIRE_MAIN_THREAD();
-  if (osr_window_)
+  if (osr_window_) {
     osr_window_->Show();
+  }
 }
 
 void BrowserWindowOsrWin::Hide() {
   REQUIRE_MAIN_THREAD();
-  if (osr_window_)
+  if (osr_window_) {
     osr_window_->Hide();
+  }
 }
 
 void BrowserWindowOsrWin::SetBounds(int x, int y, size_t width, size_t height) {
   REQUIRE_MAIN_THREAD();
-  if (osr_window_)
+  if (osr_window_) {
     osr_window_->SetBounds(x, y, width, height);
+  }
 }
 
 void BrowserWindowOsrWin::SetFocus(bool focus) {
   REQUIRE_MAIN_THREAD();
-  if (osr_window_ && focus)
+  if (osr_window_ && focus) {
     osr_window_->SetFocus();
+  }
 }
 
 void BrowserWindowOsrWin::SetDeviceScaleFactor(float device_scale_factor) {
   REQUIRE_MAIN_THREAD();
-  if (device_scale_factor == device_scale_factor_)
+  if (device_scale_factor == device_scale_factor_) {
     return;
+  }
 
   // Apply some sanity checks.
-  if (device_scale_factor < 1.0f || device_scale_factor > 4.0f)
+  if (device_scale_factor < 1.0f || device_scale_factor > 4.0f) {
     return;
+  }
 
   device_scale_factor_ = device_scale_factor;
-  if (osr_window_)
+  if (osr_window_) {
     osr_window_->SetDeviceScaleFactor(device_scale_factor);
+  }
 }
 
 float BrowserWindowOsrWin::GetDeviceScaleFactor() const {
diff --git a/tests/cefclient/browser/browser_window_std_gtk.cc b/tests/cefclient/browser/browser_window_std_gtk.cc
index 916d3aaa1..8d4bd5770 100644
--- a/tests/cefclient/browser/browser_window_std_gtk.cc
+++ b/tests/cefclient/browser/browser_window_std_gtk.cc
@@ -38,8 +38,9 @@ void SetXWindowVisible(XDisplay* xdisplay, ::Window xwindow, bool visible) {
   Atom atoms[3];
   int result =
       XInternAtoms(xdisplay, const_cast<char**>(kAtoms), 3, false, atoms);
-  if (!result)
+  if (!result) {
     NOTREACHED();
+  }
 
   if (!visible) {
     // Set the hidden property state value.
@@ -174,8 +175,9 @@ void BrowserWindowStdGtk::SetBounds(int x, int y, size_t width, size_t height) {
 void BrowserWindowStdGtk::SetFocus(bool focus) {
   REQUIRE_MAIN_THREAD();
 
-  if (browser_)
+  if (browser_) {
     browser_->GetHost()->SetFocus(focus);
+  }
 }
 
 ClientWindowHandle BrowserWindowStdGtk::GetWindowHandle() const {
diff --git a/tests/cefclient/browser/browser_window_std_mac.mm b/tests/cefclient/browser/browser_window_std_mac.mm
index 4c1a56de2..17ebc8ffa 100644
--- a/tests/cefclient/browser/browser_window_std_mac.mm
+++ b/tests/cefclient/browser/browser_window_std_mac.mm
@@ -86,8 +86,9 @@ void BrowserWindowStdMac::SetFocus(bool focus) {
 ClientWindowHandle BrowserWindowStdMac::GetWindowHandle() const {
   REQUIRE_MAIN_THREAD();
 
-  if (browser_)
+  if (browser_) {
     return browser_->GetHost()->GetWindowHandle();
+  }
   return nullptr;
 }
 
diff --git a/tests/cefclient/browser/browser_window_std_win.cc b/tests/cefclient/browser/browser_window_std_win.cc
index b8fa24c32..d363377d3 100644
--- a/tests/cefclient/browser/browser_window_std_win.cc
+++ b/tests/cefclient/browser/browser_window_std_win.cc
@@ -75,8 +75,9 @@ void BrowserWindowStdWin::Show() {
   REQUIRE_MAIN_THREAD();
 
   HWND hwnd = GetWindowHandle();
-  if (hwnd && !::IsWindowVisible(hwnd))
+  if (hwnd && !::IsWindowVisible(hwnd)) {
     ShowWindow(hwnd, SW_SHOW);
+  }
 }
 
 void BrowserWindowStdWin::Hide() {
@@ -105,15 +106,17 @@ void BrowserWindowStdWin::SetBounds(int x, int y, size_t width, size_t height) {
 void BrowserWindowStdWin::SetFocus(bool focus) {
   REQUIRE_MAIN_THREAD();
 
-  if (browser_)
+  if (browser_) {
     browser_->GetHost()->SetFocus(focus);
+  }
 }
 
 ClientWindowHandle BrowserWindowStdWin::GetWindowHandle() const {
   REQUIRE_MAIN_THREAD();
 
-  if (browser_)
+  if (browser_) {
     return browser_->GetHost()->GetWindowHandle();
+  }
   return nullptr;
 }
 
diff --git a/tests/cefclient/browser/bytes_write_handler.cc b/tests/cefclient/browser/bytes_write_handler.cc
index 25f17fa20..b05d6934f 100644
--- a/tests/cefclient/browser/bytes_write_handler.cc
+++ b/tests/cefclient/browser/bytes_write_handler.cc
@@ -19,8 +19,9 @@ BytesWriteHandler::BytesWriteHandler(size_t grow)
 }
 
 BytesWriteHandler::~BytesWriteHandler() {
-  if (data_)
+  if (data_) {
     free(data_);
+  }
 }
 
 size_t BytesWriteHandler::Write(const void* ptr, size_t size, size_t n) {
@@ -43,22 +44,25 @@ int BytesWriteHandler::Seek(int64 offset, int whence) {
   base::AutoLock lock_scope(lock_);
   switch (whence) {
     case SEEK_CUR:
-      if (offset_ + offset > datasize_ || offset_ + offset < 0)
+      if (offset_ + offset > datasize_ || offset_ + offset < 0) {
         break;
+      }
       offset_ += offset;
       rv = 0;
       break;
     case SEEK_END: {
       int64 offset_abs = std::abs(offset);
-      if (offset_abs > datasize_)
+      if (offset_abs > datasize_) {
         break;
+      }
       offset_ = datasize_ - offset_abs;
       rv = 0;
       break;
     }
     case SEEK_SET:
-      if (offset > datasize_ || offset < 0)
+      if (offset > datasize_ || offset < 0) {
         break;
+      }
       offset_ = offset;
       rv = 0;
       break;
diff --git a/tests/cefclient/browser/client_browser.cc b/tests/cefclient/browser/client_browser.cc
index 0ef19532d..b608b174d 100644
--- a/tests/cefclient/browser/client_browser.cc
+++ b/tests/cefclient/browser/client_browser.cc
@@ -55,8 +55,9 @@ class ClientBrowserDelegate : public ClientAppBrowser::Delegate {
       CefRefPtr<ClientAppBrowser> app,
       CefRefPtr<CefCommandLine> command_line) override {
     // Append Chromium command line parameters if touch events are enabled
-    if (client::MainContext::Get()->TouchEventsEnabled())
+    if (client::MainContext::Get()->TouchEventsEnabled()) {
       command_line->AppendSwitchWithValue("touch-events", "enabled");
+    }
   }
 
  private:
diff --git a/tests/cefclient/browser/client_handler.cc b/tests/cefclient/browser/client_handler.cc
index 7b3fa7197..368691af8 100644
--- a/tests/cefclient/browser/client_handler.cc
+++ b/tests/cefclient/browser/client_handler.cc
@@ -58,17 +58,19 @@ enum client_menu_ids {
 const char kFocusedNodeChangedMessage[] = "ClientRenderer.FocusedNodeChanged";
 
 std::string GetTimeString(const CefTime& value) {
-  if (value.GetTimeT() == 0)
+  if (value.GetTimeT() == 0) {
     return "Unspecified";
+  }
 
   static const char* kMonths[] = {
       "January", "February", "March",     "April",   "May",      "June",
       "July",    "August",   "September", "October", "November", "December"};
   std::string month;
-  if (value.month >= 1 && value.month <= 12)
+  if (value.month >= 1 && value.month <= 12) {
     month = kMonths[value.month - 1];
-  else
+  } else {
     month = "Invalid";
+  }
 
   std::stringstream ss;
   ss << month << " " << value.day_of_month << ", " << value.year << " "
@@ -88,8 +90,9 @@ std::string GetTimeString(const CefBaseTime& value) {
 }
 
 std::string GetBinaryString(CefRefPtr<CefBinaryValue> value) {
-  if (!value.get())
+  if (!value.get()) {
     return "&nbsp;";
+  }
 
   // Retrieve the value.
   const size_t size = value->GetSize();
@@ -132,8 +135,9 @@ std::string GetCertStatusString(cef_cert_status_t status) {
   FLAG(CERT_STATUS_SHA1_SIGNATURE_PRESENT);
   FLAG(CERT_STATUS_CT_COMPLIANCE_FAILED);
 
-  if (result.empty())
+  if (result.empty()) {
     return "&nbsp;";
+  }
   return result;
 }
 
@@ -156,8 +160,9 @@ std::string GetContentStatusString(cef_ssl_content_status_t status) {
   FLAG(SSL_CONTENT_DISPLAYED_INSECURE_CONTENT);
   FLAG(SSL_CONTENT_RAN_INSECURE_CONTENT);
 
-  if (result.empty())
+  if (result.empty()) {
     return "&nbsp;";
+  }
   return result;
 }
 
@@ -175,8 +180,9 @@ void LoadErrorPage(CefRefPtr<CefFrame> frame,
      << "</a><br/>Error: " << test_runner::GetErrorString(error_code) << " ("
      << error_code << ")";
 
-  if (!other_info.empty())
+  if (!other_info.empty()) {
     ss << "<br/>" << other_info;
+  }
 
   ss << "</body></html>";
   frame->LoadURL(test_runner::GetDataURI(ss.str(), "text/html"));
@@ -305,8 +311,9 @@ class ClientDownloadImageCallback : public CefDownloadImageCallback {
   void OnDownloadImageFinished(const CefString& image_url,
                                int http_status_code,
                                CefRefPtr<CefImage> image) override {
-    if (image)
+    if (image) {
       client_handler_->NotifyFavicon(image);
+    }
   }
 
  private:
@@ -467,8 +474,9 @@ void ClientHandler::OnBeforeContextMenu(CefRefPtr<CefBrowser> browser,
 
   if ((params->GetTypeFlags() & (CM_TYPEFLAG_PAGE | CM_TYPEFLAG_FRAME)) != 0) {
     // Add a separator if the menu already has items.
-    if (model->GetCount() > 0)
+    if (model->GetCount() > 0) {
       model->AddSeparator();
+    }
 
     if (!use_chrome_runtime) {
       // TODO(chrome-runtime): Add support for this.
@@ -489,27 +497,31 @@ void ClientHandler::OnBeforeContextMenu(CefRefPtr<CefBrowser> browser,
       model->AddSeparator();
       model->AddCheckItem(CLIENT_ID_CURSOR_CHANGE_DISABLED,
                           "Cursor change disabled");
-      if (mouse_cursor_change_disabled_)
+      if (mouse_cursor_change_disabled_) {
         model->SetChecked(CLIENT_ID_CURSOR_CHANGE_DISABLED, true);
+      }
 
       model->AddSeparator();
       model->AddCheckItem(CLIENT_ID_MEDIA_HANDLING_DISABLED,
                           "Media handling disabled");
-      if (media_handling_disabled_)
+      if (media_handling_disabled_) {
         model->SetChecked(CLIENT_ID_MEDIA_HANDLING_DISABLED, true);
+      }
     }
 
     model->AddSeparator();
     model->AddCheckItem(CLIENT_ID_OFFLINE, "Offline mode");
-    if (offline_)
+    if (offline_) {
       model->SetChecked(CLIENT_ID_OFFLINE, true);
+    }
 
     // Test context menu features.
     BuildTestMenu(model);
   }
 
-  if (delegate_)
+  if (delegate_) {
     delegate_->OnBeforeContextMenu(model);
+  }
 }
 
 bool ClientHandler::OnContextMenuCommand(CefRefPtr<CefBrowser> browser,
@@ -553,8 +565,9 @@ void ClientHandler::OnAddressChange(CefRefPtr<CefBrowser> browser,
   CEF_REQUIRE_UI_THREAD();
 
   // Only update the address for the main (top-level) frame.
-  if (frame->IsMain())
+  if (frame->IsMain()) {
     NotifyAddress(url);
+  }
 }
 
 void ClientHandler::OnTitleChange(CefRefPtr<CefBrowser> browser,
@@ -783,13 +796,15 @@ void ClientHandler::OnAfterCreated(CefRefPtr<CefBrowser> browser) {
     // Register handlers with the router.
     test_runner::CreateMessageHandlers(message_handler_set_);
     MessageHandlerSet::const_iterator it = message_handler_set_.begin();
-    for (; it != message_handler_set_.end(); ++it)
+    for (; it != message_handler_set_.end(); ++it) {
       message_router_->AddHandler(*(it), false);
+    }
   }
 
   // Set offline mode if requested via the command-line flag.
-  if (offline_)
+  if (offline_) {
     SetOfflineState(browser, true);
+  }
 
   if (browser->GetHost()->GetExtension()) {
     // Browsers hosting extension apps should auto-resize.
@@ -855,15 +870,17 @@ void ClientHandler::OnLoadError(CefRefPtr<CefBrowser> browser,
   CEF_REQUIRE_UI_THREAD();
 
   // Don't display an error for downloaded files.
-  if (errorCode == ERR_ABORTED)
+  if (errorCode == ERR_ABORTED) {
     return;
+  }
 
   // Don't display an error for external protocols that we allow the OS to
   // handle. See OnProtocolExecution().
   if (errorCode == ERR_UNKNOWN_URL_SCHEME) {
     std::string urlStr = frame->GetURL();
-    if (urlStr.find("spotify:") == 0)
+    if (urlStr.find("spotify:") == 0) {
       return;
+    }
   }
 
   // Load the error page.
@@ -1021,24 +1038,27 @@ void ClientHandler::OnRenderProcessTerminated(CefRefPtr<CefBrowser> browser,
   message_router_->OnRenderProcessTerminated(browser);
 
   // Don't reload if there's no start URL, or if the crash URL was specified.
-  if (startup_url_.empty() || startup_url_ == "chrome://crash")
+  if (startup_url_.empty() || startup_url_ == "chrome://crash") {
     return;
+  }
 
   CefRefPtr<CefFrame> frame = browser->GetMainFrame();
   std::string url = frame->GetURL();
 
   // Don't reload if the termination occurred before any URL had successfully
   // loaded.
-  if (url.empty())
+  if (url.empty()) {
     return;
+  }
 
   // Convert URLs to lowercase for easier comparison.
   url = AsciiStrToLower(url);
   const std::string& start_url = AsciiStrToLower(startup_url_);
 
   // Don't reload the URL that just resulted in termination.
-  if (url.find(start_url) == 0)
+  if (url.find(start_url) == 0) {
     return;
+  }
 
   frame->LoadURL(startup_url_);
 }
@@ -1049,8 +1069,9 @@ void ClientHandler::OnDocumentAvailableInMainFrame(
 
   // Restore offline mode after main frame navigation. Otherwise, offline state
   // (e.g. `navigator.onLine`) might be wrong in the renderer process.
-  if (offline_)
+  if (offline_) {
     SetOfflineState(browser, true);
+  }
 }
 
 cef_return_value_t ClientHandler::OnBeforeResourceLoad(
@@ -1093,8 +1114,9 @@ void ClientHandler::OnProtocolExecution(CefRefPtr<CefBrowser> browser,
   std::string urlStr = request->GetURL();
 
   // Allow OS execution of Spotify URIs.
-  if (urlStr.find("spotify:") == 0)
+  if (urlStr.find("spotify:") == 0) {
     allow_os_execution = true;
+  }
 }
 
 int ClientHandler::GetBrowserCount() const {
@@ -1152,12 +1174,14 @@ void ClientHandler::ShowSSLInformation(CefRefPtr<CefBrowser> browser) {
   std::stringstream ss;
   CefRefPtr<CefNavigationEntry> nav =
       browser->GetHost()->GetVisibleNavigationEntry();
-  if (!nav)
+  if (!nav) {
     return;
+  }
 
   CefRefPtr<CefSSLStatus> ssl = nav->GetSSLStatus();
-  if (!ssl)
+  if (!ssl) {
     return;
+  }
 
   ss << "<html><head><title>SSL Information</title></head>"
         "<body bgcolor=\"white\">"
@@ -1168,8 +1192,9 @@ void ClientHandler::ShowSSLInformation(CefRefPtr<CefBrowser> browser) {
   if (CefParseURL(nav->GetURL(), urlparts)) {
     CefString port(&urlparts.port);
     ss << "<tr><td>Server</td><td>" << CefString(&urlparts.host).ToString();
-    if (!port.empty())
+    if (!port.empty()) {
       ss << ":" << port.ToString();
+    }
     ss << "</td></tr>";
   }
 
@@ -1181,8 +1206,9 @@ void ClientHandler::ShowSSLInformation(CefRefPtr<CefBrowser> browser) {
   ss << "</table>";
 
   CefRefPtr<CefX509Certificate> cert = ssl->GetX509Certificate();
-  if (cert.get())
+  if (cert.get()) {
     ss << GetCertificateInformation(cert, ssl->GetCertStatus());
+  }
 
   ss << "</body></html>";
 
@@ -1230,8 +1256,9 @@ void ClientHandler::NotifyBrowserCreated(CefRefPtr<CefBrowser> browser) {
     return;
   }
 
-  if (delegate_)
+  if (delegate_) {
     delegate_->OnBrowserCreated(browser);
+  }
 }
 
 void ClientHandler::NotifyBrowserClosing(CefRefPtr<CefBrowser> browser) {
@@ -1242,8 +1269,9 @@ void ClientHandler::NotifyBrowserClosing(CefRefPtr<CefBrowser> browser) {
     return;
   }
 
-  if (delegate_)
+  if (delegate_) {
     delegate_->OnBrowserClosing(browser);
+  }
 }
 
 void ClientHandler::NotifyBrowserClosed(CefRefPtr<CefBrowser> browser) {
@@ -1254,8 +1282,9 @@ void ClientHandler::NotifyBrowserClosed(CefRefPtr<CefBrowser> browser) {
     return;
   }
 
-  if (delegate_)
+  if (delegate_) {
     delegate_->OnBrowserClosed(browser);
+  }
 }
 
 void ClientHandler::NotifyAddress(const CefString& url) {
@@ -1265,8 +1294,9 @@ void ClientHandler::NotifyAddress(const CefString& url) {
     return;
   }
 
-  if (delegate_)
+  if (delegate_) {
     delegate_->OnSetAddress(url);
+  }
 }
 
 void ClientHandler::NotifyTitle(const CefString& title) {
@@ -1276,8 +1306,9 @@ void ClientHandler::NotifyTitle(const CefString& title) {
     return;
   }
 
-  if (delegate_)
+  if (delegate_) {
     delegate_->OnSetTitle(title);
+  }
 }
 
 void ClientHandler::NotifyFavicon(CefRefPtr<CefImage> image) {
@@ -1288,8 +1319,9 @@ void ClientHandler::NotifyFavicon(CefRefPtr<CefImage> image) {
     return;
   }
 
-  if (delegate_)
+  if (delegate_) {
     delegate_->OnSetFavicon(image);
+  }
 }
 
 void ClientHandler::NotifyFullscreen(bool fullscreen) {
@@ -1300,8 +1332,9 @@ void ClientHandler::NotifyFullscreen(bool fullscreen) {
     return;
   }
 
-  if (delegate_)
+  if (delegate_) {
     delegate_->OnSetFullscreen(fullscreen);
+  }
 }
 
 void ClientHandler::NotifyAutoResize(const CefSize& new_size) {
@@ -1312,8 +1345,9 @@ void ClientHandler::NotifyAutoResize(const CefSize& new_size) {
     return;
   }
 
-  if (delegate_)
+  if (delegate_) {
     delegate_->OnAutoResize(new_size);
+  }
 }
 
 void ClientHandler::NotifyLoadingState(bool isLoading,
@@ -1326,8 +1360,9 @@ void ClientHandler::NotifyLoadingState(bool isLoading,
     return;
   }
 
-  if (delegate_)
+  if (delegate_) {
     delegate_->OnSetLoadingState(isLoading, canGoBack, canGoForward);
+  }
 }
 
 void ClientHandler::NotifyDraggableRegions(
@@ -1339,8 +1374,9 @@ void ClientHandler::NotifyDraggableRegions(
     return;
   }
 
-  if (delegate_)
+  if (delegate_) {
     delegate_->OnSetDraggableRegions(regions);
+  }
 }
 
 void ClientHandler::NotifyTakeFocus(bool next) {
@@ -1351,13 +1387,15 @@ void ClientHandler::NotifyTakeFocus(bool next) {
     return;
   }
 
-  if (delegate_)
+  if (delegate_) {
     delegate_->OnTakeFocus(next);
+  }
 }
 
 void ClientHandler::BuildTestMenu(CefRefPtr<CefMenuModel> model) {
-  if (model->GetCount() > 0)
+  if (model->GetCount() > 0) {
     model->AddSeparator();
+  }
 
   // Build the sub menu.
   CefRefPtr<CefMenuModel> submenu =
@@ -1368,8 +1406,9 @@ void ClientHandler::BuildTestMenu(CefRefPtr<CefMenuModel> model) {
   submenu->AddRadioItem(CLIENT_ID_TESTMENU_RADIOITEM3, "Radio Item 3", 0);
 
   // Check the check item.
-  if (test_menu_state_.check_item)
+  if (test_menu_state_.check_item) {
     submenu->SetChecked(CLIENT_ID_TESTMENU_CHECKITEM, true);
+  }
 
   // Check the selected radio item.
   submenu->SetChecked(
@@ -1454,8 +1493,9 @@ bool ClientHandler::IsAllowedCommandId(int command_id) {
       IDC_CONTENT_CONTEXT_REDO,
   };
   for (size_t i = 0; i < std::size(kAllowedCommandIds); ++i) {
-    if (command_id == kAllowedCommandIds[i])
+    if (command_id == kAllowedCommandIds[i]) {
       return true;
+    }
   }
   return false;
 }
diff --git a/tests/cefclient/browser/client_handler_osr.cc b/tests/cefclient/browser/client_handler_osr.cc
index 14ea3286e..2f36af9b4 100644
--- a/tests/cefclient/browser/client_handler_osr.cc
+++ b/tests/cefclient/browser/client_handler_osr.cc
@@ -33,23 +33,26 @@ void ClientHandlerOsr::DetachOsrDelegate() {
 
 void ClientHandlerOsr::OnAfterCreated(CefRefPtr<CefBrowser> browser) {
   CEF_REQUIRE_UI_THREAD();
-  if (osr_delegate_)
+  if (osr_delegate_) {
     osr_delegate_->OnAfterCreated(browser);
+  }
   ClientHandler::OnAfterCreated(browser);
 }
 
 void ClientHandlerOsr::OnBeforeClose(CefRefPtr<CefBrowser> browser) {
   CEF_REQUIRE_UI_THREAD();
-  if (osr_delegate_)
+  if (osr_delegate_) {
     osr_delegate_->OnBeforeClose(browser);
+  }
   ClientHandler::OnBeforeClose(browser);
 }
 
 bool ClientHandlerOsr::GetRootScreenRect(CefRefPtr<CefBrowser> browser,
                                          CefRect& rect) {
   CEF_REQUIRE_UI_THREAD();
-  if (!osr_delegate_)
+  if (!osr_delegate_) {
     return false;
+  }
   return osr_delegate_->GetRootScreenRect(browser, rect);
 }
 
@@ -70,31 +73,35 @@ bool ClientHandlerOsr::GetScreenPoint(CefRefPtr<CefBrowser> browser,
                                       int& screenX,
                                       int& screenY) {
   CEF_REQUIRE_UI_THREAD();
-  if (!osr_delegate_)
+  if (!osr_delegate_) {
     return false;
+  }
   return osr_delegate_->GetScreenPoint(browser, viewX, viewY, screenX, screenY);
 }
 
 bool ClientHandlerOsr::GetScreenInfo(CefRefPtr<CefBrowser> browser,
                                      CefScreenInfo& screen_info) {
   CEF_REQUIRE_UI_THREAD();
-  if (!osr_delegate_)
+  if (!osr_delegate_) {
     return false;
+  }
   return osr_delegate_->GetScreenInfo(browser, screen_info);
 }
 
 void ClientHandlerOsr::OnPopupShow(CefRefPtr<CefBrowser> browser, bool show) {
   CEF_REQUIRE_UI_THREAD();
-  if (!osr_delegate_)
+  if (!osr_delegate_) {
     return;
+  }
   return osr_delegate_->OnPopupShow(browser, show);
 }
 
 void ClientHandlerOsr::OnPopupSize(CefRefPtr<CefBrowser> browser,
                                    const CefRect& rect) {
   CEF_REQUIRE_UI_THREAD();
-  if (!osr_delegate_)
+  if (!osr_delegate_) {
     return;
+  }
   return osr_delegate_->OnPopupSize(browser, rect);
 }
 
@@ -105,8 +112,9 @@ void ClientHandlerOsr::OnPaint(CefRefPtr<CefBrowser> browser,
                                int width,
                                int height) {
   CEF_REQUIRE_UI_THREAD();
-  if (!osr_delegate_)
+  if (!osr_delegate_) {
     return;
+  }
   osr_delegate_->OnPaint(browser, type, dirtyRects, buffer, width, height);
 }
 
@@ -116,8 +124,9 @@ void ClientHandlerOsr::OnAcceleratedPaint(
     const CefRenderHandler::RectList& dirtyRects,
     void* share_handle) {
   CEF_REQUIRE_UI_THREAD();
-  if (!osr_delegate_)
+  if (!osr_delegate_) {
     return;
+  }
   osr_delegate_->OnAcceleratedPaint(browser, type, dirtyRects, share_handle);
 }
 
@@ -128,8 +137,9 @@ bool ClientHandlerOsr::StartDragging(
     int x,
     int y) {
   CEF_REQUIRE_UI_THREAD();
-  if (!osr_delegate_)
+  if (!osr_delegate_) {
     return false;
+  }
   return osr_delegate_->StartDragging(browser, drag_data, allowed_ops, x, y);
 }
 
@@ -137,8 +147,9 @@ void ClientHandlerOsr::UpdateDragCursor(
     CefRefPtr<CefBrowser> browser,
     CefRenderHandler::DragOperation operation) {
   CEF_REQUIRE_UI_THREAD();
-  if (!osr_delegate_)
+  if (!osr_delegate_) {
     return;
+  }
   osr_delegate_->UpdateDragCursor(browser, operation);
 }
 
@@ -147,16 +158,18 @@ void ClientHandlerOsr::OnImeCompositionRangeChanged(
     const CefRange& selection_range,
     const CefRenderHandler::RectList& character_bounds) {
   CEF_REQUIRE_UI_THREAD();
-  if (!osr_delegate_)
+  if (!osr_delegate_) {
     return;
+  }
   osr_delegate_->OnImeCompositionRangeChanged(browser, selection_range,
                                               character_bounds);
 }
 
 void ClientHandlerOsr::OnAccessibilityTreeChange(CefRefPtr<CefValue> value) {
   CEF_REQUIRE_UI_THREAD();
-  if (!osr_delegate_)
+  if (!osr_delegate_) {
     return;
+  }
   osr_delegate_->UpdateAccessibilityTree(value);
 }
 
@@ -178,8 +191,9 @@ bool ClientHandlerOsr::OnCursorChange(CefRefPtr<CefBrowser> browser,
 void ClientHandlerOsr::OnAccessibilityLocationChange(
     CefRefPtr<CefValue> value) {
   CEF_REQUIRE_UI_THREAD();
-  if (!osr_delegate_)
+  if (!osr_delegate_) {
     return;
+  }
   osr_delegate_->UpdateAccessibilityLocation(value);
 }
 
diff --git a/tests/cefclient/browser/client_prefs.cc b/tests/cefclient/browser/client_prefs.cc
index 2c229205c..e64a1de67 100644
--- a/tests/cefclient/browser/client_prefs.cc
+++ b/tests/cefclient/browser/client_prefs.cc
@@ -133,20 +133,24 @@ CefRect ClampBoundsToDisplay(const CefRect& dip_bounds) {
 
   CefRect bounds = dip_bounds;
 
-  if (bounds.width > work_area.width)
+  if (bounds.width > work_area.width) {
     bounds.width = work_area.width;
-  if (bounds.height > work_area.height)
+  }
+  if (bounds.height > work_area.height) {
     bounds.height = work_area.height;
+  }
 
-  if (bounds.x < work_area.x)
+  if (bounds.x < work_area.x) {
     bounds.x = work_area.x;
-  else if (bounds.x + bounds.width >= work_area.x + work_area.width)
+  } else if (bounds.x + bounds.width >= work_area.x + work_area.width) {
     bounds.x = work_area.x + work_area.width - bounds.width;
+  }
 
-  if (bounds.y < work_area.y)
+  if (bounds.y < work_area.y) {
     bounds.y = work_area.y;
-  else if (bounds.y + bounds.height >= work_area.y + work_area.height)
+  } else if (bounds.y + bounds.height >= work_area.y + work_area.height) {
     bounds.y = work_area.y + work_area.height - bounds.height;
+  }
 
   return bounds;
 }
diff --git a/tests/cefclient/browser/dialog_handler_gtk.cc b/tests/cefclient/browser/dialog_handler_gtk.cc
index e31660f10..33e687bb3 100644
--- a/tests/cefclient/browser/dialog_handler_gtk.cc
+++ b/tests/cefclient/browser/dialog_handler_gtk.cc
@@ -24,8 +24,9 @@ const char kPromptTextId[] = "cef_prompt_text";
 std::string GetPromptText(GtkDialog* dialog) {
   GtkWidget* widget = static_cast<GtkWidget*>(
       g_object_get_data(G_OBJECT(dialog), kPromptTextId));
-  if (widget)
+  if (widget) {
     return gtk_entry_get_text(GTK_ENTRY(widget));
+  }
   return std::string();
 }
 
@@ -43,8 +44,9 @@ std::string GetDescriptionFromMimeType(const std::string& mime_type) {
 
   for (size_t i = 0;
        i < sizeof(kWildCardMimeTypes) / sizeof(kWildCardMimeTypes[0]); ++i) {
-    if (mime_type == std::string(kWildCardMimeTypes[i].mime_type) + "/*")
+    if (mime_type == std::string(kWildCardMimeTypes[i].mime_type) + "/*") {
       return std::string(kWildCardMimeTypes[i].label);
+    }
   }
 
   return std::string();
@@ -58,8 +60,9 @@ void AddFilters(GtkFileChooser* chooser,
 
   for (size_t j = 0; j < accept_filters.size(); ++j) {
     const std::string& filter = accept_filters[j];
-    if (filter.empty())
+    if (filter.empty()) {
       continue;
+    }
 
     std::vector<std::string> extensions;
     std::string description;
@@ -75,8 +78,9 @@ void AddFilters(GtkFileChooser* chooser,
       for (size_t i = 0; i <= size; ++i) {
         if (i == size || exts[i] == ';') {
           std::string ext(exts, last, i - last);
-          if (!ext.empty() && ext[0] == '.')
+          if (!ext.empty() && ext[0] == '.') {
             extensions.push_back(ext);
+          }
           last = i + 1;
         }
       }
@@ -89,33 +93,38 @@ void AddFilters(GtkFileChooser* chooser,
 
       std::vector<CefString> ext;
       CefGetExtensionsForMimeType(filter, ext);
-      for (size_t x = 0; x < ext.size(); ++x)
+      for (size_t x = 0; x < ext.size(); ++x) {
         extensions.push_back("." + ext[x].ToString());
+      }
     }
 
-    if (extensions.empty())
+    if (extensions.empty()) {
       continue;
+    }
 
     GtkFileFilter* gtk_filter = gtk_file_filter_new();
 
     std::string ext_str;
     for (size_t x = 0; x < extensions.size(); ++x) {
       const std::string& pattern = "*" + extensions[x];
-      if (x != 0)
+      if (x != 0) {
         ext_str += ";";
+      }
       ext_str += pattern;
       gtk_file_filter_add_pattern(gtk_filter, pattern.c_str());
     }
 
-    if (description.empty())
+    if (description.empty()) {
       description = ext_str;
-    else
+    } else {
       description += " (" + ext_str + ")";
+    }
 
     gtk_file_filter_set_name(gtk_filter, description.c_str());
     gtk_file_chooser_add_filter(chooser, gtk_filter);
-    if (!has_filter)
+    if (!has_filter) {
       has_filter = true;
+    }
 
     filters->push_back(gtk_filter);
   }
@@ -137,8 +146,9 @@ GtkWindow* GetWindow(CefRefPtr<CefBrowser> browser) {
   if (root_window) {
     GtkWidget* window = root_window->GetWindowHandle();
     DCHECK(window);
-    if (!window)
+    if (!window) {
       LOG(ERROR) << "No GtkWindow for browser";
+    }
     return GTK_WINDOW(window);
   }
   return nullptr;
@@ -212,8 +222,9 @@ bool ClientDialogHandlerGtk::OnBeforeUnloadDialog(
 void ClientDialogHandlerGtk::OnResetDialogState(CefRefPtr<CefBrowser> browser) {
   CEF_REQUIRE_UI_THREAD();
 
-  if (!gtk_dialog_)
+  if (!gtk_dialog_) {
     return;
+  }
 
   gtk_widget_destroy(gtk_dialog_);
   gtk_dialog_ = nullptr;
@@ -274,8 +285,9 @@ void ClientDialogHandlerGtk::OnFileDialogContinue(
       title_str.c_str(), GTK_WINDOW(window), action, "_Cancel",
       GTK_RESPONSE_CANCEL, accept_button, GTK_RESPONSE_ACCEPT, nullptr);
 
-  if (params.mode == FILE_DIALOG_OPEN_MULTIPLE)
+  if (params.mode == FILE_DIALOG_OPEN_MULTIPLE) {
     gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
+  }
 
   if (!params.default_file_path.empty() && params.mode == FILE_DIALOG_SAVE) {
     const std::string& file_path = params.default_file_path;
@@ -326,10 +338,11 @@ void ClientDialogHandlerGtk::OnFileDialogContinue(
 
   gtk_widget_destroy(dialog);
 
-  if (success)
+  if (success) {
     params.callback->Continue(files);
-  else
+  } else {
     params.callback->Cancel();
+  }
 }
 
 void ClientDialogHandlerGtk::OnJSDialogContinue(const OnJSDialogParams& params,
@@ -380,8 +393,9 @@ void ClientDialogHandlerGtk::OnJSDialogContinue(const OnJSDialogParams& params,
   GtkWidget* ok_button =
       gtk_dialog_add_button(GTK_DIALOG(gtk_dialog_), "_OK", GTK_RESPONSE_OK);
 
-  if (params.dialog_type != JSDIALOGTYPE_PROMPT)
+  if (params.dialog_type != JSDIALOGTYPE_PROMPT) {
     gtk_widget_grab_focus(ok_button);
+  }
 
   if (params.dialog_type == JSDIALOGTYPE_PROMPT) {
     GtkWidget* content_area =
diff --git a/tests/cefclient/browser/dialog_test.cc b/tests/cefclient/browser/dialog_test.cc
index 27a985404..78d23d835 100644
--- a/tests/cefclient/browser/dialog_test.cc
+++ b/tests/cefclient/browser/dialog_test.cc
@@ -64,8 +64,9 @@ class DialogCallback : public CefRunFileDialogCallback {
     // Send a message back to the render process with the list of file paths.
     std::string response;
     for (int i = 0; i < static_cast<int>(file_paths.size()); ++i) {
-      if (!response.empty())
+      if (!response.empty()) {
         response += "|";  // Use a delimiter disallowed in file paths.
+      }
       response += file_paths[i];
     }
 
@@ -100,11 +101,13 @@ class Handler : public CefMessageRouterBrowserSide::Handler {
 
     // Only handle messages from the test URL.
     const std::string& url = frame->GetURL();
-    if (!test_runner::IsTestURL(url, kTestUrlPath))
+    if (!test_runner::IsTestURL(url, kTestUrlPath)) {
       return false;
+    }
 
-    if (!dialog_state_.get())
+    if (!dialog_state_.get()) {
       dialog_state_ = new DialogState;
+    }
 
     // Make sure we're only running one dialog at a time.
     DCHECK(!dialog_state_->pending_);
diff --git a/tests/cefclient/browser/image_cache.cc b/tests/cefclient/browser/image_cache.cc
index efbe67b72..216459386 100644
--- a/tests/cefclient/browser/image_cache.cc
+++ b/tests/cefclient/browser/image_cache.cc
@@ -37,8 +37,9 @@ ImageCache::ImageInfo::ImageInfo(const std::string& id,
     : id_(id), reps_(reps), internal_(internal), force_reload_(force_reload) {
 #ifndef NDEBUG
   DCHECK(!id_.empty());
-  if (id_ != kEmptyId)
+  if (id_ != kEmptyId) {
     DCHECK(!reps_.empty());
+  }
 #endif
 }
 
@@ -129,8 +130,9 @@ void ImageCache::LoadImages(const ImageInfoSet& image_info,
 
     // Load the image.
     images.push_back(nullptr);
-    if (!missing_images)
+    if (!missing_images) {
       missing_images = true;
+    }
   }
 
   if (missing_images) {
@@ -147,8 +149,9 @@ CefRefPtr<CefImage> ImageCache::GetCachedImage(const std::string& image_id) {
   DCHECK(!image_id.empty());
 
   ImageMap::const_iterator it = image_map_.find(image_id);
-  if (it != image_map_.end())
+  if (it != image_map_.end()) {
     return it->second;
+  }
 
   return nullptr;
 }
@@ -156,14 +159,17 @@ CefRefPtr<CefImage> ImageCache::GetCachedImage(const std::string& image_id) {
 // static
 ImageCache::ImageType ImageCache::GetImageType(const std::string& path) {
   std::string ext = file_util::GetFileExtension(path);
-  if (ext.empty())
+  if (ext.empty()) {
     return TYPE_NONE;
+  }
 
   ext = AsciiStrToLower(ext);
-  if (ext == "png")
+  if (ext == "png") {
     return TYPE_PNG;
-  if (ext == "jpg" || ext == "jpeg")
+  }
+  if (ext == "jpg" || ext == "jpeg") {
     return TYPE_JPEG;
+  }
 
   return TYPE_NONE;
 }
@@ -226,12 +232,14 @@ bool ImageCache::LoadImageContents(const std::string& path,
   CEF_REQUIRE_FILE_USER_BLOCKING_THREAD();
 
   *type = GetImageType(path);
-  if (*type == TYPE_NONE)
+  if (*type == TYPE_NONE) {
     return false;
+  }
 
   if (internal) {
-    if (!LoadBinaryResource(path.c_str(), *contents))
+    if (!LoadBinaryResource(path.c_str(), *contents)) {
       return false;
+    }
   } else if (!file_util::ReadFileToString(path, contents)) {
     return false;
   }
@@ -276,8 +284,9 @@ CefRefPtr<CefImage> ImageCache::CreateImage(const std::string& image_id,
   // Shouldn't be creating an image if one already exists.
   DCHECK(!content.image_);
 
-  if (content.contents_.empty())
+  if (content.contents_.empty()) {
     return nullptr;
+  }
 
   CefRefPtr<CefImage> image = CefImage::CreateImage();
 
diff --git a/tests/cefclient/browser/main_context_impl.cc b/tests/cefclient/browser/main_context_impl.cc
index 5c8b4fc2e..949cf8904 100644
--- a/tests/cefclient/browser/main_context_impl.cc
+++ b/tests/cefclient/browser/main_context_impl.cc
@@ -21,16 +21,17 @@ const char kDefaultUrl[] = "http://www.google.com";
 // Returns the ARGB value for |color|.
 cef_color_t ParseColor(const std::string& color) {
   const std::string& colorToLower = AsciiStrToLower(color);
-  if (colorToLower == "black")
+  if (colorToLower == "black") {
     return CefColorSetARGB(255, 0, 0, 0);
-  else if (colorToLower == "blue")
+  } else if (colorToLower == "blue") {
     return CefColorSetARGB(255, 0, 0, 255);
-  else if (colorToLower == "green")
+  } else if (colorToLower == "green") {
     return CefColorSetARGB(255, 0, 255, 0);
-  else if (colorToLower == "red")
+  } else if (colorToLower == "red") {
     return CefColorSetARGB(255, 255, 0, 0);
-  else if (colorToLower == "white")
+  } else if (colorToLower == "white") {
     return CefColorSetARGB(255, 255, 255, 255);
+  }
 
   // Use the default color.
   return 0;
@@ -45,10 +46,12 @@ MainContextImpl::MainContextImpl(CefRefPtr<CefCommandLine> command_line,
   DCHECK(command_line_.get());
 
   // Set the main URL.
-  if (command_line_->HasSwitch(switches::kUrl))
+  if (command_line_->HasSwitch(switches::kUrl)) {
     main_url_ = command_line_->GetSwitchValue(switches::kUrl);
-  if (main_url_.empty())
+  }
+  if (main_url_.empty()) {
     main_url_ = kDefaultUrl;
+  }
 
   // Whether windowless (off-screen) rendering will be used.
   use_windowless_rendering_ =
@@ -187,17 +190,20 @@ bool MainContextImpl::UseDefaultPopup() {
 void MainContextImpl::PopulateSettings(CefSettings* settings) {
   client::ClientAppBrowser::PopulateSettings(command_line_, *settings);
 
-  if (use_chrome_runtime_)
+  if (use_chrome_runtime_) {
     settings->chrome_runtime = true;
+  }
 
   CefString(&settings->cache_path) =
       command_line_->GetSwitchValue(switches::kCachePath);
 
-  if (use_windowless_rendering_)
+  if (use_windowless_rendering_) {
     settings->windowless_rendering_enabled = true;
+  }
 
-  if (browser_background_color_ != 0)
+  if (browser_background_color_ != 0) {
     settings->background_color = browser_background_color_;
+  }
 
   if (command_line_->HasSwitch("lang")) {
     // Use the same locale for the Accept-Language HTTP request header.
@@ -209,8 +215,9 @@ void MainContextImpl::PopulateSettings(CefSettings* settings) {
 void MainContextImpl::PopulateBrowserSettings(CefBrowserSettings* settings) {
   settings->windowless_frame_rate = windowless_frame_rate_;
 
-  if (browser_background_color_ != 0)
+  if (browser_background_color_ != 0) {
     settings->background_color = browser_background_color_;
+  }
 
   if (use_chrome_runtime_ &&
       command_line_->HasSwitch(switches::kHideChromeStatusBubble)) {
@@ -228,8 +235,9 @@ void MainContextImpl::PopulateOsrSettings(OsrRendererSettings* settings) {
   settings->external_begin_frame_enabled = external_begin_frame_enabled_;
   settings->begin_frame_rate = windowless_frame_rate_;
 
-  if (browser_background_color_ != 0)
+  if (browser_background_color_ != 0) {
     settings->background_color = browser_background_color_;
+  }
 }
 
 RootWindowManager* MainContextImpl::GetRootWindowManager() {
@@ -245,8 +253,9 @@ bool MainContextImpl::Initialize(const CefMainArgs& args,
   DCHECK(!initialized_);
   DCHECK(!shutdown_);
 
-  if (!CefInitialize(args, settings, application, windows_sandbox_info))
+  if (!CefInitialize(args, settings, application, windows_sandbox_info)) {
     return false;
+  }
 
   // Need to create the RootWindowManager after calling CefInitialize because
   // TempWindowX11 uses cef_get_xdisplay().
diff --git a/tests/cefclient/browser/main_message_loop_multithreaded_win.cc b/tests/cefclient/browser/main_message_loop_multithreaded_win.cc
index 2da484c60..156cd3e42 100644
--- a/tests/cefclient/browser/main_message_loop_multithreaded_win.cc
+++ b/tests/cefclient/browser/main_message_loop_multithreaded_win.cc
@@ -61,8 +61,9 @@ int MainMessageLoopMultithreadedWin::Run() {
   // Run the application message loop.
   while (GetMessage(&msg, nullptr, 0, 0)) {
     // Allow processing of dialog messages.
-    if (dialog_hwnd_ && IsDialogMessage(dialog_hwnd_, &msg))
+    if (dialog_hwnd_ && IsDialogMessage(dialog_hwnd_, &msg)) {
       continue;
+    }
 
     if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) {
       TranslateMessage(&msg);
diff --git a/tests/cefclient/browser/media_router_test.cc b/tests/cefclient/browser/media_router_test.cc
index 65437227b..54483dedc 100644
--- a/tests/cefclient/browser/media_router_test.cc
+++ b/tests/cefclient/browser/media_router_test.cc
@@ -254,15 +254,17 @@ class MediaObserver : public CefMediaObserver {
  private:
   CefRefPtr<CefMediaSource> GetSource(const std::string& source_urn) {
     CefRefPtr<CefMediaSource> source = media_router_->GetSource(source_urn);
-    if (!source)
+    if (!source) {
       return nullptr;
+    }
     return source;
   }
 
   CefRefPtr<CefMediaSink> GetSink(const std::string& sink_id) {
     SinkInfoMap::const_iterator it = sink_info_map_.find(sink_id);
-    if (it != sink_info_map_.end())
+    if (it != sink_info_map_.end()) {
       return it->second->sink;
+    }
     return nullptr;
   }
 
@@ -278,8 +280,9 @@ class MediaObserver : public CefMediaObserver {
                         const std::string& sink_id,
                         const CefMediaSinkDeviceInfo& device_info) {
     // Discard callbacks that arrive after a new call to OnSinks().
-    if (sink_query_id != pending_sink_query_id_)
+    if (sink_query_id != pending_sink_query_id_) {
       return;
+    }
 
     SinkInfoMap::const_iterator it = sink_info_map_.find(sink_id);
     if (it != sink_info_map_.end()) {
@@ -295,8 +298,9 @@ class MediaObserver : public CefMediaObserver {
 
   CefRefPtr<CefMediaRoute> GetRoute(const std::string& route_id) {
     RouteMap::const_iterator it = route_map_.find(route_id);
-    if (it != route_map_.end())
+    if (it != route_map_.end()) {
       return it->second;
+    }
     return nullptr;
   }
 
@@ -327,10 +331,9 @@ class MediaObserver : public CefMediaObserver {
       sink_dict->SetInt("port", info->device_info.port);
       sink_dict->SetString("model_name",
                            CefString(&info->device_info.model_name));
-      sink_dict->SetString("type",
-                           info->sink->IsCastSink()
-                               ? "cast"
-                               : info->sink->IsDialSink() ? "dial" : "unknown");
+      sink_dict->SetString("type", info->sink->IsCastSink()   ? "cast"
+                                   : info->sink->IsDialSink() ? "dial"
+                                                              : "unknown");
       sinks_list->SetDictionary(idx, sink_dict);
     }
 
@@ -389,8 +392,9 @@ class Handler : public CefMessageRouterBrowserSide::Handler {
 
     // Only handle messages from the test URL.
     const std::string& url = frame->GetURL();
-    if (!test_runner::IsTestURL(url, kTestUrlPath))
+    if (!test_runner::IsTestURL(url, kTestUrlPath)) {
       return false;
+    }
 
     // Parse |request| as a JSON dictionary.
     CefRefPtr<CefDictionaryValue> request_dict = ParseJSON(request);
@@ -400,8 +404,9 @@ class Handler : public CefMessageRouterBrowserSide::Handler {
     }
 
     // Verify the "name" key.
-    if (!VerifyKey(request_dict, kNameKey, VTYPE_STRING, callback))
+    if (!VerifyKey(request_dict, kNameKey, VTYPE_STRING, callback)) {
       return true;
+    }
 
     const std::string& message_name = request_dict->GetString(kNameKey);
     if (message_name == kNameValueSubscribe) {
@@ -432,11 +437,13 @@ class Handler : public CefMessageRouterBrowserSide::Handler {
       // Create a new route.
 
       // Verify the "source_urn" key.
-      if (!VerifyKey(request_dict, kSourceKey, VTYPE_STRING, callback))
+      if (!VerifyKey(request_dict, kSourceKey, VTYPE_STRING, callback)) {
         return true;
+      }
       // Verify the "sink_id" key.
-      if (!VerifyKey(request_dict, kSinkKey, VTYPE_STRING, callback))
+      if (!VerifyKey(request_dict, kSinkKey, VTYPE_STRING, callback)) {
         return true;
+      }
 
       const std::string& source_urn = request_dict->GetString(kSourceKey);
       const std::string& sink_id = request_dict->GetString(kSinkKey);
@@ -451,8 +458,9 @@ class Handler : public CefMessageRouterBrowserSide::Handler {
       // Terminate an existing route.
 
       // Verify the "route" key.
-      if (!VerifyKey(request_dict, kRouteKey, VTYPE_STRING, callback))
+      if (!VerifyKey(request_dict, kRouteKey, VTYPE_STRING, callback)) {
         return true;
+      }
 
       const std::string& route_id = request_dict->GetString(kRouteKey);
       std::string error;
@@ -466,11 +474,13 @@ class Handler : public CefMessageRouterBrowserSide::Handler {
       // Send a route message.
 
       // Verify the "route_id" key.
-      if (!VerifyKey(request_dict, kRouteKey, VTYPE_STRING, callback))
+      if (!VerifyKey(request_dict, kRouteKey, VTYPE_STRING, callback)) {
         return true;
+      }
       // Verify the "message" key.
-      if (!VerifyKey(request_dict, kMessageKey, VTYPE_STRING, callback))
+      if (!VerifyKey(request_dict, kMessageKey, VTYPE_STRING, callback)) {
         return true;
+      }
 
       const std::string& route_id = request_dict->GetString(kRouteKey);
       const std::string& message = request_dict->GetString(kMessageKey);
@@ -503,8 +513,9 @@ class Handler : public CefMessageRouterBrowserSide::Handler {
   // Convert a JSON string to a dictionary value.
   static CefRefPtr<CefDictionaryValue> ParseJSON(const CefString& string) {
     CefRefPtr<CefValue> value = CefParseJSON(string, JSON_PARSER_RFC);
-    if (value.get() && value->GetType() == VTYPE_DICTIONARY)
+    if (value.get() && value->GetType() == VTYPE_DICTIONARY) {
       return value->GetDictionary();
+    }
     return nullptr;
   }
 
diff --git a/tests/cefclient/browser/osr_accessibility_helper.cc b/tests/cefclient/browser/osr_accessibility_helper.cc
index 01fafc027..caf3796d8 100644
--- a/tests/cefclient/browser/osr_accessibility_helper.cc
+++ b/tests/cefclient/browser/osr_accessibility_helper.cc
@@ -38,8 +38,7 @@ void OsrAXTree::UpdateTreeData(CefRefPtr<CefDictionaryValue> value) {
 
 OsrAccessibilityHelper::OsrAccessibilityHelper(CefRefPtr<CefValue> value,
                                                CefRefPtr<CefBrowser> browser)
-    : focused_node_id_(-1),
-      browser_(browser) {
+    : focused_node_id_(-1), browser_(browser) {
   UpdateAccessibilityTree(value);
 }
 
diff --git a/tests/cefclient/browser/osr_accessibility_node.cc b/tests/cefclient/browser/osr_accessibility_node.cc
index fdee83f2a..648d50a93 100644
--- a/tests/cefclient/browser/osr_accessibility_node.cc
+++ b/tests/cefclient/browser/osr_accessibility_node.cc
@@ -41,16 +41,18 @@ void OsrAXNode::UpdateLocation(CefRefPtr<CefDictionaryValue> value) {
 }
 
 void OsrAXNode::UpdateValue(CefRefPtr<CefDictionaryValue> value) {
-  if (value->HasKey("role"))
+  if (value->HasKey("role")) {
     role_ = value->GetString("role");
+  }
 
   if (value->HasKey("child_ids")) {
     CefRefPtr<CefListValue> childs = value->GetList("child_ids");
     // Reset child Ids
     child_ids_.clear();
-    for (size_t idx = 0; idx < childs->GetSize(); idx++)
+    for (size_t idx = 0; idx < childs->GetSize(); idx++) {
       child_ids_.push_back(
           OsrAccessibilityHelper::CastToInt(childs->GetValue(idx)));
+    }
   }
   // Update Location
   if (value->HasKey("location")) {
@@ -85,24 +87,29 @@ void OsrAXNode::UpdateValue(CefRefPtr<CefDictionaryValue> value) {
     if (attributes_ && attributes_->HasKey("childTreeId")) {
       child_tree_id_ = attributes_->GetString("childTreeId");
     }
-    if (attributes_ && attributes_->HasKey("name"))
+    if (attributes_ && attributes_->HasKey("name")) {
       name_ = attributes_->GetString("name");
-    if (attributes_ && attributes_->HasKey("value"))
+    }
+    if (attributes_ && attributes_->HasKey("value")) {
       value_ = attributes_->GetString("value");
-    if (attributes_ && attributes_->HasKey("description"))
+    }
+    if (attributes_ && attributes_->HasKey("description")) {
       description_ = attributes_->GetString("description");
+    }
   }
 }
 
 CefWindowHandle OsrAXNode::GetWindowHandle() const {
-  if (accessibility_helper_)
+  if (accessibility_helper_) {
     return accessibility_helper_->GetWindowHandle();
+  }
   return nullptr;
 }
 
 CefRefPtr<CefBrowser> OsrAXNode::GetBrowser() const {
-  if (accessibility_helper_)
+  if (accessibility_helper_) {
     return accessibility_helper_->GetBrowser();
+  }
   return nullptr;
 }
 
@@ -149,8 +156,9 @@ int OsrAXNode::GetChildCount() const {
 
 OsrAXNode* OsrAXNode::ChildAtIndex(int index) const {
   int count = static_cast<int>(child_ids_.size());
-  if (index < count)
+  if (index < count) {
     return accessibility_helper_->GetNode(OsrAXTreeId(), child_ids_[index]);
+  }
   if ((index == count) && (!child_tree_id_.empty())) {
     OsrAXNode* childTreeRootNode =
         accessibility_helper_->GetTreeRootNode(child_tree_id_);
diff --git a/tests/cefclient/browser/osr_accessibility_node_mac.mm b/tests/cefclient/browser/osr_accessibility_node_mac.mm
index 2fbb8da1c..b5d5c3811 100644
--- a/tests/cefclient/browser/osr_accessibility_node_mac.mm
+++ b/tests/cefclient/browser/osr_accessibility_node_mac.mm
@@ -15,220 +15,327 @@
 namespace {
 
 NSString* AxRoleToNSAxRole(const std::string& role_string) {
-  if (role_string == "abbr")
+  if (role_string == "abbr") {
     return NSAccessibilityGroupRole;
-  if (role_string == "alertDialog")
+  }
+  if (role_string == "alertDialog") {
     return NSAccessibilityGroupRole;
-  if (role_string == "alert")
+  }
+  if (role_string == "alert") {
     return NSAccessibilityGroupRole;
-  if (role_string == "annotation")
+  }
+  if (role_string == "annotation") {
     return NSAccessibilityUnknownRole;
-  if (role_string == "application")
+  }
+  if (role_string == "application") {
     return NSAccessibilityGroupRole;
-  if (role_string == "article")
+  }
+  if (role_string == "article") {
     return NSAccessibilityGroupRole;
-  if (role_string == "audio")
+  }
+  if (role_string == "audio") {
     return NSAccessibilityGroupRole;
-  if (role_string == "banner")
+  }
+  if (role_string == "banner") {
     return NSAccessibilityGroupRole;
-  if (role_string == "blockquote")
+  }
+  if (role_string == "blockquote") {
     return NSAccessibilityGroupRole;
-  if (role_string == "busyIndicator")
+  }
+  if (role_string == "busyIndicator") {
     return NSAccessibilityBusyIndicatorRole;
-  if (role_string == "button")
+  }
+  if (role_string == "button") {
     return NSAccessibilityButtonRole;
-  if (role_string == "buttonDropDown")
+  }
+  if (role_string == "buttonDropDown") {
     return NSAccessibilityButtonRole;
-  if (role_string == "canvas")
+  }
+  if (role_string == "canvas") {
     return NSAccessibilityImageRole;
-  if (role_string == "caption")
+  }
+  if (role_string == "caption") {
     return NSAccessibilityGroupRole;
-  if (role_string == "checkBox")
+  }
+  if (role_string == "checkBox") {
     return NSAccessibilityCheckBoxRole;
-  if (role_string == "colorWell")
+  }
+  if (role_string == "colorWell") {
     return NSAccessibilityColorWellRole;
-  if (role_string == "column")
+  }
+  if (role_string == "column") {
     return NSAccessibilityColumnRole;
-  if (role_string == "comboBox")
+  }
+  if (role_string == "comboBox") {
     return NSAccessibilityComboBoxRole;
-  if (role_string == "complementary")
+  }
+  if (role_string == "complementary") {
     return NSAccessibilityGroupRole;
-  if (role_string == "contentInfo")
+  }
+  if (role_string == "contentInfo") {
     return NSAccessibilityGroupRole;
-  if (role_string == "definition")
+  }
+  if (role_string == "definition") {
     return NSAccessibilityGroupRole;
-  if (role_string == "descriptionListDetail")
+  }
+  if (role_string == "descriptionListDetail") {
     return NSAccessibilityGroupRole;
-  if (role_string == "descriptionList")
+  }
+  if (role_string == "descriptionList") {
     return NSAccessibilityListRole;
-  if (role_string == "descriptionListTerm")
+  }
+  if (role_string == "descriptionListTerm") {
     return NSAccessibilityGroupRole;
-  if (role_string == "details")
+  }
+  if (role_string == "details") {
     return NSAccessibilityGroupRole;
-  if (role_string == "dialog")
+  }
+  if (role_string == "dialog") {
     return NSAccessibilityGroupRole;
-  if (role_string == "directory")
+  }
+  if (role_string == "directory") {
     return NSAccessibilityListRole;
-  if (role_string == "disclosureTriangle")
+  }
+  if (role_string == "disclosureTriangle") {
     return NSAccessibilityDisclosureTriangleRole;
-  if (role_string == "div")
+  }
+  if (role_string == "div") {
     return NSAccessibilityGroupRole;
-  if (role_string == "document")
+  }
+  if (role_string == "document") {
     return NSAccessibilityGroupRole;
-  if (role_string == "embeddedObject")
+  }
+  if (role_string == "embeddedObject") {
     return NSAccessibilityGroupRole;
-  if (role_string == "figcaption")
+  }
+  if (role_string == "figcaption") {
     return NSAccessibilityGroupRole;
-  if (role_string == "figure")
+  }
+  if (role_string == "figure") {
     return NSAccessibilityGroupRole;
-  if (role_string == "footer")
+  }
+  if (role_string == "footer") {
     return NSAccessibilityGroupRole;
-  if (role_string == "form")
+  }
+  if (role_string == "form") {
     return NSAccessibilityGroupRole;
-  if (role_string == "genericContainer")
+  }
+  if (role_string == "genericContainer") {
     return NSAccessibilityGroupRole;
-  if (role_string == "grid")
+  }
+  if (role_string == "grid") {
     return NSAccessibilityGroupRole;
-  if (role_string == "group")
+  }
+  if (role_string == "group") {
     return NSAccessibilityGroupRole;
-  if (role_string == "iframe")
+  }
+  if (role_string == "iframe") {
     return NSAccessibilityGroupRole;
-  if (role_string == "iframePresentational")
+  }
+  if (role_string == "iframePresentational") {
     return NSAccessibilityGroupRole;
-  if (role_string == "ignored")
+  }
+  if (role_string == "ignored") {
     return NSAccessibilityUnknownRole;
-  if (role_string == "imageMapLink")
+  }
+  if (role_string == "imageMapLink") {
     return NSAccessibilityLinkRole;
-  if (role_string == "imageMap")
+  }
+  if (role_string == "imageMap") {
     return NSAccessibilityGroupRole;
-  if (role_string == "image")
+  }
+  if (role_string == "image") {
     return NSAccessibilityImageRole;
-  if (role_string == "labelText")
+  }
+  if (role_string == "labelText") {
     return NSAccessibilityGroupRole;
-  if (role_string == "legend")
+  }
+  if (role_string == "legend") {
     return NSAccessibilityGroupRole;
-  if (role_string == "link")
+  }
+  if (role_string == "link") {
     return NSAccessibilityLinkRole;
-  if (role_string == "listBoxOption")
+  }
+  if (role_string == "listBoxOption") {
     return NSAccessibilityStaticTextRole;
-  if (role_string == "listBox")
+  }
+  if (role_string == "listBox") {
     return NSAccessibilityListRole;
-  if (role_string == "listItem")
+  }
+  if (role_string == "listItem") {
     return NSAccessibilityGroupRole;
-  if (role_string == "list")
+  }
+  if (role_string == "list") {
     return NSAccessibilityListRole;
-  if (role_string == "log")
+  }
+  if (role_string == "log") {
     return NSAccessibilityGroupRole;
-  if (role_string == "main")
+  }
+  if (role_string == "main") {
     return NSAccessibilityGroupRole;
-  if (role_string == "mark")
+  }
+  if (role_string == "mark") {
     return NSAccessibilityGroupRole;
-  if (role_string == "marquee")
+  }
+  if (role_string == "marquee") {
     return NSAccessibilityGroupRole;
-  if (role_string == "math")
+  }
+  if (role_string == "math") {
     return NSAccessibilityGroupRole;
-  if (role_string == "menu")
+  }
+  if (role_string == "menu") {
     return NSAccessibilityMenuRole;
-  if (role_string == "menuBar")
+  }
+  if (role_string == "menuBar") {
     return NSAccessibilityMenuBarRole;
-  if (role_string == "menuButton")
+  }
+  if (role_string == "menuButton") {
     return NSAccessibilityButtonRole;
-  if (role_string == "menuItem")
+  }
+  if (role_string == "menuItem") {
     return NSAccessibilityMenuItemRole;
-  if (role_string == "menuItemCheckBox")
+  }
+  if (role_string == "menuItemCheckBox") {
     return NSAccessibilityMenuItemRole;
-  if (role_string == "menuItemRadio")
+  }
+  if (role_string == "menuItemRadio") {
     return NSAccessibilityMenuItemRole;
-  if (role_string == "menuListOption")
+  }
+  if (role_string == "menuListOption") {
     return NSAccessibilityMenuItemRole;
-  if (role_string == "menuListPopup")
+  }
+  if (role_string == "menuListPopup") {
     return NSAccessibilityUnknownRole;
-  if (role_string == "meter")
+  }
+  if (role_string == "meter") {
     return NSAccessibilityProgressIndicatorRole;
-  if (role_string == "navigation")
+  }
+  if (role_string == "navigation") {
     return NSAccessibilityGroupRole;
-  if (role_string == "note")
+  }
+  if (role_string == "note") {
     return NSAccessibilityGroupRole;
-  if (role_string == "outline")
+  }
+  if (role_string == "outline") {
     return NSAccessibilityOutlineRole;
-  if (role_string == "paragraph")
+  }
+  if (role_string == "paragraph") {
     return NSAccessibilityGroupRole;
-  if (role_string == "popUpButton")
+  }
+  if (role_string == "popUpButton") {
     return NSAccessibilityPopUpButtonRole;
-  if (role_string == "pre")
+  }
+  if (role_string == "pre") {
     return NSAccessibilityGroupRole;
-  if (role_string == "presentational")
+  }
+  if (role_string == "presentational") {
     return NSAccessibilityGroupRole;
-  if (role_string == "progressIndicator")
+  }
+  if (role_string == "progressIndicator") {
     return NSAccessibilityProgressIndicatorRole;
-  if (role_string == "radioButton")
+  }
+  if (role_string == "radioButton") {
     return NSAccessibilityRadioButtonRole;
-  if (role_string == "radioGroup")
+  }
+  if (role_string == "radioGroup") {
     return NSAccessibilityRadioGroupRole;
-  if (role_string == "region")
+  }
+  if (role_string == "region") {
     return NSAccessibilityGroupRole;
-  if (role_string == "row")
+  }
+  if (role_string == "row") {
     return NSAccessibilityRowRole;
-  if (role_string == "ruler")
+  }
+  if (role_string == "ruler") {
     return NSAccessibilityRulerRole;
-  if (role_string == "scrollBar")
+  }
+  if (role_string == "scrollBar") {
     return NSAccessibilityScrollBarRole;
-  if (role_string == "search")
+  }
+  if (role_string == "search") {
     return NSAccessibilityGroupRole;
-  if (role_string == "searchBox")
+  }
+  if (role_string == "searchBox") {
     return NSAccessibilityTextFieldRole;
-  if (role_string == "slider")
+  }
+  if (role_string == "slider") {
     return NSAccessibilitySliderRole;
-  if (role_string == "sliderThumb")
+  }
+  if (role_string == "sliderThumb") {
     return NSAccessibilityValueIndicatorRole;
-  if (role_string == "spinButton")
+  }
+  if (role_string == "spinButton") {
     return NSAccessibilityIncrementorRole;
-  if (role_string == "splitter")
+  }
+  if (role_string == "splitter") {
     return NSAccessibilitySplitterRole;
-  if (role_string == "staticText")
+  }
+  if (role_string == "staticText") {
     return NSAccessibilityStaticTextRole;
-  if (role_string == "status")
+  }
+  if (role_string == "status") {
     return NSAccessibilityGroupRole;
-  if (role_string == "svgRoot")
+  }
+  if (role_string == "svgRoot") {
     return NSAccessibilityGroupRole;
-  if (role_string == "switch")
+  }
+  if (role_string == "switch") {
     return NSAccessibilityCheckBoxRole;
-  if (role_string == "tabGroup")
+  }
+  if (role_string == "tabGroup") {
     return NSAccessibilityTabGroupRole;
-  if (role_string == "tabList")
+  }
+  if (role_string == "tabList") {
     return NSAccessibilityTabGroupRole;
-  if (role_string == "tabPanel")
+  }
+  if (role_string == "tabPanel") {
     return NSAccessibilityGroupRole;
-  if (role_string == "tab")
+  }
+  if (role_string == "tab") {
     return NSAccessibilityRadioButtonRole;
-  if (role_string == "tableHeaderContainer")
+  }
+  if (role_string == "tableHeaderContainer") {
     return NSAccessibilityGroupRole;
-  if (role_string == "table")
+  }
+  if (role_string == "table") {
     return NSAccessibilityTableRole;
-  if (role_string == "textField")
+  }
+  if (role_string == "textField") {
     return NSAccessibilityTextFieldRole;
-  if (role_string == "time")
+  }
+  if (role_string == "time") {
     return NSAccessibilityGroupRole;
-  if (role_string == "timer")
+  }
+  if (role_string == "timer") {
     return NSAccessibilityGroupRole;
-  if (role_string == "toggleButton")
+  }
+  if (role_string == "toggleButton") {
     return NSAccessibilityCheckBoxRole;
-  if (role_string == "toolbar")
+  }
+  if (role_string == "toolbar") {
     return NSAccessibilityToolbarRole;
-  if (role_string == "treeGrid")
+  }
+  if (role_string == "treeGrid") {
     return NSAccessibilityTableRole;
-  if (role_string == "treeItem")
+  }
+  if (role_string == "treeItem") {
     return NSAccessibilityRowRole;
-  if (role_string == "tree")
+  }
+  if (role_string == "tree") {
     return NSAccessibilityOutlineRole;
-  if (role_string == "unknown")
+  }
+  if (role_string == "unknown") {
     return NSAccessibilityUnknownRole;
-  if (role_string == "tooltip")
+  }
+  if (role_string == "tooltip") {
     return NSAccessibilityGroupRole;
-  if (role_string == "video")
+  }
+  if (role_string == "video") {
     return NSAccessibilityGroupRole;
-  if (role_string == "window")
+  }
+  if (role_string == "window") {
     return NSAccessibilityWindowRole;
+  }
   return [NSString stringWithUTF8String:role_string.c_str()];
 }
 
@@ -387,8 +494,9 @@ inline int MiddleY(const CefRect& rect) {
 
 - (id)accessibilityAttributeValue:(NSString*)attribute {
   NSObject* typed_parent = CAST_CEF_NATIVE_ACCESSIBLE_TO_NSOBJECT(parent_);
-  if (!node_)
+  if (!node_) {
     return nil;
+  }
   if ([attribute isEqualToString:NSAccessibilityRoleAttribute]) {
     return [self axRole];
   } else if ([attribute
diff --git a/tests/cefclient/browser/osr_accessibility_node_win.cc b/tests/cefclient/browser/osr_accessibility_node_win.cc
index a96889a12..5c5e64fb2 100644
--- a/tests/cefclient/browser/osr_accessibility_node_win.cc
+++ b/tests/cefclient/browser/osr_accessibility_node_win.cc
@@ -40,72 +40,105 @@ void ClientToScreen(HWND hwnd, LPRECT lpRect) {
 
 // Helper function to convert to MSAARole
 int AxRoleToMSAARole(const std::string& role_string) {
-  if (role_string == "alert")
+  if (role_string == "alert") {
     return ROLE_SYSTEM_ALERT;
-  if (role_string == "application")
+  }
+  if (role_string == "application") {
     return ROLE_SYSTEM_APPLICATION;
-  if (role_string == "buttonDropDown")
+  }
+  if (role_string == "buttonDropDown") {
     return ROLE_SYSTEM_BUTTONDROPDOWN;
-  if (role_string == "popUpButton")
+  }
+  if (role_string == "popUpButton") {
     return ROLE_SYSTEM_BUTTONMENU;
-  if (role_string == "checkBox")
+  }
+  if (role_string == "checkBox") {
     return ROLE_SYSTEM_CHECKBUTTON;
-  if (role_string == "comboBox")
+  }
+  if (role_string == "comboBox") {
     return ROLE_SYSTEM_COMBOBOX;
-  if (role_string == "dialog")
+  }
+  if (role_string == "dialog") {
     return ROLE_SYSTEM_DIALOG;
-  if (role_string == "genericContainer")
+  }
+  if (role_string == "genericContainer") {
     return ROLE_SYSTEM_GROUPING;
-  if (role_string == "group")
+  }
+  if (role_string == "group") {
     return ROLE_SYSTEM_GROUPING;
-  if (role_string == "image")
+  }
+  if (role_string == "image") {
     return ROLE_SYSTEM_GRAPHIC;
-  if (role_string == "link")
+  }
+  if (role_string == "link") {
     return ROLE_SYSTEM_LINK;
-  if (role_string == "locationBar")
+  }
+  if (role_string == "locationBar") {
     return ROLE_SYSTEM_GROUPING;
-  if (role_string == "menuBar")
+  }
+  if (role_string == "menuBar") {
     return ROLE_SYSTEM_MENUBAR;
-  if (role_string == "menuItem")
+  }
+  if (role_string == "menuItem") {
     return ROLE_SYSTEM_MENUITEM;
-  if (role_string == "menuListPopup")
+  }
+  if (role_string == "menuListPopup") {
     return ROLE_SYSTEM_MENUPOPUP;
-  if (role_string == "tree")
+  }
+  if (role_string == "tree") {
     return ROLE_SYSTEM_OUTLINE;
-  if (role_string == "treeItem")
+  }
+  if (role_string == "treeItem") {
     return ROLE_SYSTEM_OUTLINEITEM;
-  if (role_string == "tab")
+  }
+  if (role_string == "tab") {
     return ROLE_SYSTEM_PAGETAB;
-  if (role_string == "tabList")
+  }
+  if (role_string == "tabList") {
     return ROLE_SYSTEM_PAGETABLIST;
-  if (role_string == "pane")
+  }
+  if (role_string == "pane") {
     return ROLE_SYSTEM_PANE;
-  if (role_string == "progressIndicator")
+  }
+  if (role_string == "progressIndicator") {
     return ROLE_SYSTEM_PROGRESSBAR;
-  if (role_string == "button")
+  }
+  if (role_string == "button") {
     return ROLE_SYSTEM_PUSHBUTTON;
-  if (role_string == "radioButton")
+  }
+  if (role_string == "radioButton") {
     return ROLE_SYSTEM_RADIOBUTTON;
-  if (role_string == "scrollBar")
+  }
+  if (role_string == "scrollBar") {
     return ROLE_SYSTEM_SCROLLBAR;
-  if (role_string == "splitter")
+  }
+  if (role_string == "splitter") {
     return ROLE_SYSTEM_SEPARATOR;
-  if (role_string == "slider")
+  }
+  if (role_string == "slider") {
     return ROLE_SYSTEM_SLIDER;
-  if (role_string == "staticText")
+  }
+  if (role_string == "staticText") {
     return ROLE_SYSTEM_STATICTEXT;
-  if (role_string == "textField")
+  }
+  if (role_string == "textField") {
     return ROLE_SYSTEM_TEXT;
-  if (role_string == "titleBar")
+  }
+  if (role_string == "titleBar") {
     return ROLE_SYSTEM_TITLEBAR;
-  if (role_string == "toolbar")
+  }
+  if (role_string == "toolbar") {
     return ROLE_SYSTEM_TOOLBAR;
-  if (role_string == "webView")
+  }
+  if (role_string == "webView") {
     return ROLE_SYSTEM_GROUPING;
-  if (role_string == "window")
+  }
+  if (role_string == "window") {
     return ROLE_SYSTEM_WINDOW;
-  if (role_string == "client")
+  }
+  if (role_string == "client") {
     return ROLE_SYSTEM_CLIENT;
+  }
   // This is the default role for MSAA.
   return ROLE_SYSTEM_CLIENT;
 }
@@ -235,17 +268,19 @@ struct CefIAccessible : public IAccessible {
 // Handles ref counting and querying for other supported interfaces.
 // We only support, IUnknown, IDispatch and IAccessible.
 STDMETHODIMP CefIAccessible::QueryInterface(REFIID riid, void** ppvObject) {
-  if (riid == IID_IAccessible)
+  if (riid == IID_IAccessible) {
     *ppvObject = static_cast<IAccessible*>(this);
-  else if (riid == IID_IDispatch)
+  } else if (riid == IID_IDispatch) {
     *ppvObject = static_cast<IDispatch*>(this);
-  else if (riid == IID_IUnknown)
+  } else if (riid == IID_IUnknown) {
     *ppvObject = static_cast<IUnknown*>(this);
-  else
+  } else {
     *ppvObject = nullptr;
+  }
 
-  if (*ppvObject)
+  if (*ppvObject) {
     reinterpret_cast<IUnknown*>(*ppvObject)->AddRef();
+  }
 
   return (*ppvObject) ? S_OK : E_NOINTERFACE;
 }
@@ -259,8 +294,9 @@ STDMETHODIMP_(ULONG) CefIAccessible::Release() {
   ULONG ulRefCnt = InterlockedDecrement((LONG volatile*)&ref_count_);
   if (ulRefCnt == 0) {
     // Remove reference from OsrAXNode
-    if (node_)
+    if (node_) {
       node_->Destroy();
+    }
     delete this;
   }
 
@@ -286,8 +322,9 @@ STDMETHODIMP CefIAccessible::get_accParent(IDispatch** ppdispParent) {
         }
       }
 
-      if (parent)
+      if (parent) {
         parent->AddRef();
+      }
       *ppdispParent = parent;
       retCode = (*ppdispParent) ? S_OK : S_FALSE;
     }
@@ -327,15 +364,17 @@ STDMETHODIMP CefIAccessible::get_accChild(VARIANT varChild,
           // Convert to 0 based index and get Child Node.
           OsrAXNode* child = node_->ChildAtIndex(varChild.lVal - 1);
           // Fallback to focused node
-          if (!child)
+          if (!child) {
             child = node_->GetAccessibilityHelper()->GetFocusedNode();
+          }
 
           *ppdispChild = child->GetNativeAccessibleObject(node_);
         }
-        if (*ppdispChild == nullptr)
+        if (*ppdispChild == nullptr) {
           retCode = S_FALSE;
-        else
+        } else {
           (*ppdispChild)->AddRef();
+        }
       }
     }
   }
@@ -436,10 +475,11 @@ STDMETHODIMP CefIAccessible::get_accKeyboardShortcut(
     BSTR* pszKeyboardShortcut) {
   HRESULT retCode = DATACHECK(node_);
   if (SUCCEEDED(retCode)) {
-    if (pszKeyboardShortcut && VALID_CHILDID(varChild))
+    if (pszKeyboardShortcut && VALID_CHILDID(varChild)) {
       *pszKeyboardShortcut = ::SysAllocString(L"None");
-    else
+    } else {
       retCode = E_INVALIDARG;
+    }
   }
   return retCode;
 }
@@ -450,8 +490,9 @@ STDMETHODIMP CefIAccessible::get_accFocus(VARIANT* pFocusChild) {
   if (SUCCEEDED(retCode)) {
     OsrAXNode* focusedNode = node_->GetAccessibilityHelper()->GetFocusedNode();
     CefNativeAccessible* nativeObj = nullptr;
-    if (focusedNode)
+    if (focusedNode) {
       nativeObj = focusedNode->GetNativeAccessibleObject(nullptr);
+    }
 
     if (nativeObj) {
       if (nativeObj == this) {
@@ -473,10 +514,11 @@ STDMETHODIMP CefIAccessible::get_accFocus(VARIANT* pFocusChild) {
 STDMETHODIMP CefIAccessible::get_accSelection(VARIANT* pvarChildren) {
   HRESULT retCode = DATACHECK(node_);
   if (SUCCEEDED(retCode)) {
-    if (pvarChildren)
+    if (pvarChildren) {
       pvarChildren->vt = VT_EMPTY;
-    else
+    } else {
       retCode = E_INVALIDARG;
+    }
   }
   return retCode;
 }
@@ -486,10 +528,11 @@ STDMETHODIMP CefIAccessible::get_accDefaultAction(VARIANT varChild,
                                                   BSTR* pszDefaultAction) {
   HRESULT retCode = DATACHECK(node_);
   if (SUCCEEDED(retCode)) {
-    if (pszDefaultAction && VALID_CHILDID(varChild))
+    if (pszDefaultAction && VALID_CHILDID(varChild)) {
       *pszDefaultAction = ::SysAllocString(L"Push");
-    else
+    } else {
       retCode = E_INVALIDARG;
+    }
   }
   return retCode;
 }
@@ -661,8 +704,9 @@ void OsrAXNode::NotifyAccessibilityEvent(std::string event_type) const {
 
 void OsrAXNode::Destroy() {
   CefIAccessible* ptr = static_cast<CefIAccessible*>(platform_accessibility_);
-  if (ptr)
+  if (ptr) {
     ptr->MarkDestroyed();
+  }
   platform_accessibility_ = nullptr;
 }
 
diff --git a/tests/cefclient/browser/osr_d3d11_win.cc b/tests/cefclient/browser/osr_d3d11_win.cc
index ca23d0731..14af7a9b8 100644
--- a/tests/cefclient/browser/osr_d3d11_win.cc
+++ b/tests/cefclient/browser/osr_d3d11_win.cc
@@ -37,8 +37,9 @@ namespace {
 template <class T>
 std::shared_ptr<T> to_com_ptr(T* obj) {
   return std::shared_ptr<T>(obj, [](T* p) {
-    if (p)
+    if (p) {
       p->Release();
+    }
   });
 }
 
@@ -695,8 +696,9 @@ std::shared_ptr<ID3DBlob> Device::compile_shader(const std::string& source_code,
   }
 
   return std::shared_ptr<ID3DBlob>(blob, [](ID3DBlob* p) {
-    if (p)
+    if (p) {
       p->Release();
+    }
   });
 }
 
diff --git a/tests/cefclient/browser/osr_dragdrop_win.cc b/tests/cefclient/browser/osr_dragdrop_win.cc
index c880ac02c..04d699486 100644
--- a/tests/cefclient/browser/osr_dragdrop_win.cc
+++ b/tests/cefclient/browser/osr_dragdrop_win.cc
@@ -24,23 +24,29 @@ namespace {
 
 DWORD DragOperationToDropEffect(CefRenderHandler::DragOperation allowed_ops) {
   DWORD effect = DROPEFFECT_NONE;
-  if (allowed_ops & DRAG_OPERATION_COPY)
+  if (allowed_ops & DRAG_OPERATION_COPY) {
     effect |= DROPEFFECT_COPY;
-  if (allowed_ops & DRAG_OPERATION_LINK)
+  }
+  if (allowed_ops & DRAG_OPERATION_LINK) {
     effect |= DROPEFFECT_LINK;
-  if (allowed_ops & DRAG_OPERATION_MOVE)
+  }
+  if (allowed_ops & DRAG_OPERATION_MOVE) {
     effect |= DROPEFFECT_MOVE;
+  }
   return effect;
 }
 
 CefRenderHandler::DragOperationsMask DropEffectToDragOperation(DWORD effect) {
   DWORD operation = DRAG_OPERATION_NONE;
-  if (effect & DROPEFFECT_COPY)
+  if (effect & DROPEFFECT_COPY) {
     operation |= DRAG_OPERATION_COPY;
-  if (effect & DROPEFFECT_LINK)
+  }
+  if (effect & DROPEFFECT_LINK) {
     operation |= DRAG_OPERATION_LINK;
-  if (effect & DROPEFFECT_MOVE)
+  }
+  if (effect & DROPEFFECT_MOVE) {
     operation |= DRAG_OPERATION_MOVE;
+  }
   return static_cast<CefRenderHandler::DragOperationsMask>(operation);
 }
 
@@ -93,8 +99,9 @@ void GetStorageForFileDescriptor(STGMEDIUM* storage,
 // Documentation for the CF_HTML format is available at
 // http://msdn.microsoft.com/en-us/library/aa767917(VS.85).aspx
 std::string HtmlToCFHtml(const std::string& html, const std::string& base_url) {
-  if (html.empty())
+  if (html.empty()) {
     return std::string();
+  }
 
 #define MAX_DIGITS 10
 #define MAKE_NUMBER_FORMAT_1(digits) MAKE_NUMBER_FORMAT_2(digits)
@@ -279,8 +286,9 @@ CefRefPtr<CefDragData> DataObjectToDragData(IDataObject* data_object) {
   CefRefPtr<CefDragData> drag_data = CefDragData::Create();
   IEnumFORMATETC* enumFormats = nullptr;
   HRESULT res = data_object->EnumFormatEtc(DATADIR_GET, &enumFormats);
-  if (res != S_OK)
+  if (res != S_OK) {
     return drag_data;
+  }
   enumFormats->Reset();
   const int kCelt = 10;
 
@@ -294,8 +302,9 @@ CefRefPtr<CefDragData> DataObjectToDragData(IDataObject* data_object) {
       if (!(format == CF_UNICODETEXT || format == CF_TEXT ||
             format == moz_url_format || format == html_format ||
             format == CF_HDROP) ||
-          rgelt[i].tymed != TYMED_HGLOBAL)
+          rgelt[i].tymed != TYMED_HGLOBAL) {
         continue;
+      }
       STGMEDIUM medium;
       if (data_object->GetData(&rgelt[i], &medium) == S_OK) {
         if (!medium.hGlobal) {
@@ -336,18 +345,21 @@ CefRefPtr<CefDragData> DataObjectToDragData(IDataObject* data_object) {
           const unsigned num_files = DragQueryFileW(hdrop, 0xffffffff, 0, 0);
           for (unsigned int x = 0; x < num_files; ++x) {
             wchar_t filename[kMaxFilenameLen];
-            if (!DragQueryFileW(hdrop, x, filename, kMaxFilenameLen))
+            if (!DragQueryFileW(hdrop, x, filename, kMaxFilenameLen)) {
               continue;
+            }
             WCHAR* name = wcsrchr(filename, '\\');
             drag_data->AddFile(filename, (name ? name + 1 : filename));
           }
         }
-        if (medium.hGlobal)
+        if (medium.hGlobal) {
           GlobalUnlock(medium.hGlobal);
-        if (format == CF_HDROP)
+        }
+        if (format == CF_HDROP) {
           DragFinish((HDROP)hGlobal);
-        else
+        } else {
           ReleaseStgMedium(&medium);
+        }
       }
     }
   } while (res == S_OK);
@@ -366,8 +378,9 @@ HRESULT DropTargetWin::DragEnter(IDataObject* data_object,
                                  DWORD key_state,
                                  POINTL cursor_position,
                                  DWORD* effect) {
-  if (!callback_)
+  if (!callback_) {
     return E_UNEXPECTED;
+  }
 
   CefRefPtr<CefDragData> drag_data = current_drag_data_;
   if (!drag_data) {
@@ -394,8 +407,9 @@ CefBrowserHost::DragOperationsMask DropTargetWin::StartDragging(
     current_drag_data_ = drag_data->Clone();
     current_drag_data_->ResetFileContents();
     HRESULT res = DoDragDrop(dataObject, dropSource, effect, &resEffect);
-    if (res != DRAGDROP_S_DROP)
+    if (res != DRAGDROP_S_DROP) {
       resEffect = DROPEFFECT_NONE;
+    }
     current_drag_data_ = nullptr;
   }
   return DropEffectToDragOperation(resEffect);
@@ -404,8 +418,9 @@ CefBrowserHost::DragOperationsMask DropTargetWin::StartDragging(
 HRESULT DropTargetWin::DragOver(DWORD key_state,
                                 POINTL cursor_position,
                                 DWORD* effect) {
-  if (!callback_)
+  if (!callback_) {
     return E_UNEXPECTED;
+  }
   CefMouseEvent ev = ToMouseEvent(cursor_position, key_state, hWnd_);
   CefBrowserHost::DragOperationsMask mask = DropEffectToDragOperation(*effect);
   mask = callback_->OnDragOver(ev, mask);
@@ -414,8 +429,9 @@ HRESULT DropTargetWin::DragOver(DWORD key_state,
 }
 
 HRESULT DropTargetWin::DragLeave() {
-  if (!callback_)
+  if (!callback_) {
     return E_UNEXPECTED;
+  }
   callback_->OnDragLeave();
   return S_OK;
 }
@@ -424,8 +440,9 @@ HRESULT DropTargetWin::Drop(IDataObject* data_object,
                             DWORD key_state,
                             POINTL cursor_position,
                             DWORD* effect) {
-  if (!callback_)
+  if (!callback_) {
     return E_UNEXPECTED;
+  }
   CefMouseEvent ev = ToMouseEvent(cursor_position, key_state, hWnd_);
   CefBrowserHost::DragOperationsMask mask = DropEffectToDragOperation(*effect);
   mask = callback_->OnDrop(ev, mask);
@@ -458,8 +475,9 @@ HRESULT DragEnumFormatEtc::CreateEnumFormatEtc(
     UINT cfmt,
     FORMATETC* afmt,
     IEnumFORMATETC** ppEnumFormatEtc) {
-  if (cfmt == 0 || afmt == 0 || ppEnumFormatEtc == 0)
+  if (cfmt == 0 || afmt == 0 || ppEnumFormatEtc == 0) {
     return E_INVALIDARG;
+  }
 
   *ppEnumFormatEtc = new DragEnumFormatEtc(afmt, cfmt);
 
@@ -479,8 +497,9 @@ HRESULT DragEnumFormatEtc::Next(ULONG celt,
   }
 
   // store result
-  if (pceltFetched != 0)
+  if (pceltFetched != 0) {
     *pceltFetched = copied;
+  }
 
   // did we copy all that was requested?
   return (copied == celt) ? S_OK : S_FALSE;
@@ -522,8 +541,9 @@ DragEnumFormatEtc::DragEnumFormatEtc(FORMATETC* pFormatEtc, int nNumFormats) {
 DragEnumFormatEtc::~DragEnumFormatEtc() {
   // first free any DVTARGETDEVICE structures
   for (ULONG i = 0; i < m_nNumFormats; i++) {
-    if (m_pFormatEtc[i].ptd)
+    if (m_pFormatEtc[i].ptd) {
       CoTaskMemFree(m_pFormatEtc[i].ptd);
+    }
   }
 
   // now free the main array
@@ -594,8 +614,9 @@ HRESULT DataObjectWin::GetData(FORMATETC* pFormatEtc, STGMEDIUM* pMedium) {
   int idx;
 
   // try to match the specified FORMATETC with one of our supported formats
-  if ((idx = LookupFormatEtc(pFormatEtc)) == -1)
+  if ((idx = LookupFormatEtc(pFormatEtc)) == -1) {
     return DV_E_FORMATETC;
+  }
 
   // found a match - transfer data into supplied storage medium
   pMedium->tymed = m_pFormatEtc[idx].tymed;
diff --git a/tests/cefclient/browser/osr_dragdrop_win.h b/tests/cefclient/browser/osr_dragdrop_win.h
index caf9613c2..29ef2605d 100644
--- a/tests/cefclient/browser/osr_dragdrop_win.h
+++ b/tests/cefclient/browser/osr_dragdrop_win.h
@@ -37,17 +37,19 @@ namespace client {
     AddRef();                                                       \
     return S_OK;                                                    \
   }
-#define IUNKNOWN_IMPLEMENTATION                     \
-  ULONG __stdcall AddRef() { return ++ref_count_; } \
-  ULONG __stdcall Release() {                       \
-    if (--ref_count_ == 0) {                        \
-      delete this;                                  \
-      return 0U;                                    \
-    }                                               \
-    return ref_count_;                              \
-  }                                                 \
-                                                    \
- protected:                                         \
+#define IUNKNOWN_IMPLEMENTATION \
+  ULONG __stdcall AddRef() {    \
+    return ++ref_count_;        \
+  }                             \
+  ULONG __stdcall Release() {   \
+    if (--ref_count_ == 0) {    \
+      delete this;              \
+      return 0U;                \
+    }                           \
+    return ref_count_;          \
+  }                             \
+                                \
+ protected:                     \
   ULONG ref_count_;
 
 class DropTargetWin : public IDropTarget {
diff --git a/tests/cefclient/browser/osr_ime_handler_win.cc b/tests/cefclient/browser/osr_ime_handler_win.cc
index 6e8546fcd..3f0921cfd 100644
--- a/tests/cefclient/browser/osr_ime_handler_win.cc
+++ b/tests/cefclient/browser/osr_ime_handler_win.cc
@@ -46,12 +46,14 @@ void GetCompositionSelectionRange(HIMC imc,
     ::ImmGetCompositionString(imc, GCS_COMPATTR, &attribute_data[0],
                               attribute_size);
     for (start = 0; start < attribute_size; ++start) {
-      if (IsSelectionAttribute(attribute_data[start]))
+      if (IsSelectionAttribute(attribute_data[start])) {
         break;
+      }
     }
     for (end = start; end < attribute_size; ++end) {
-      if (!IsSelectionAttribute(attribute_data[end]))
+      if (!IsSelectionAttribute(attribute_data[end])) {
         break;
+      }
     }
 
     *target_start = start;
@@ -133,8 +135,9 @@ void OsrImeHandlerWin::CreateImeWindow() {
   if (PRIMARYLANGID(input_language_id_) == LANG_CHINESE ||
       PRIMARYLANGID(input_language_id_) == LANG_JAPANESE) {
     if (!system_caret_) {
-      if (::CreateCaret(hwnd_, nullptr, 1, 1))
+      if (::CreateCaret(hwnd_, nullptr, 1, 1)) {
         system_caret_ = true;
+      }
     }
   }
 }
@@ -149,24 +152,28 @@ void OsrImeHandlerWin::DestroyImeWindow() {
 
 void OsrImeHandlerWin::MoveImeWindow() {
   // Does nothing when the target window has no input focus.
-  if (GetFocus() != hwnd_)
+  if (GetFocus() != hwnd_) {
     return;
+  }
 
   CefRect rc = ime_rect_;
   int location = cursor_index_;
 
   // If location is not specified fall back to the composition range start.
-  if (location == -1)
+  if (location == -1) {
     location = composition_range_.from;
+  }
 
   // Offset location by the composition range start if required.
-  if (location >= composition_range_.from)
+  if (location >= composition_range_.from) {
     location -= composition_range_.from;
+  }
 
-  if (location < static_cast<int>(composition_bounds_.size()))
+  if (location < static_cast<int>(composition_bounds_.size())) {
     rc = composition_bounds_[location];
-  else
+  } else {
     return;
+  }
 
   HIMC imc = ::ImmGetContext(hwnd_);
   if (imc) {
@@ -251,8 +258,9 @@ void OsrImeHandlerWin::GetCompositionInfo(
   // Find out the range selected by the user.
   int target_start = length;
   int target_end = length;
-  if (lparam & GCS_COMPATTR)
+  if (lparam & GCS_COMPATTR) {
     GetCompositionSelectionRange(imc, &target_start, &target_end);
+  }
 
   // Retrieve the selection range information. If CS_NOMOVECARET is specified
   // it means the cursor should not be moved and we therefore place the caret at
@@ -271,8 +279,9 @@ void OsrImeHandlerWin::GetCompositionInfo(
   }
 
   // Retrieve the clause segmentations and convert them to underlines.
-  if (lparam & GCS_COMPCLAUSE)
+  if (lparam & GCS_COMPCLAUSE) {
     GetCompositionUnderlines(imc, target_start, target_end, underlines);
+  }
 
   // Set default underlines in case there is no clause information.
   if (!underlines.size()) {
@@ -304,11 +313,13 @@ bool OsrImeHandlerWin::GetString(HIMC imc,
                                  WPARAM lparam,
                                  int type,
                                  CefString& result) {
-  if (!(lparam & type))
+  if (!(lparam & type)) {
     return false;
+  }
   LONG string_size = ::ImmGetCompositionString(imc, type, nullptr, 0);
-  if (string_size <= 0)
+  if (string_size <= 0) {
     return false;
+  }
 
   // For trailing nullptr - ImmGetCompositionString excludes that.
   string_size += sizeof(WCHAR);
diff --git a/tests/cefclient/browser/osr_render_handler_win_d3d11.cc b/tests/cefclient/browser/osr_render_handler_win_d3d11.cc
index db46691b0..93de15a5f 100644
--- a/tests/cefclient/browser/osr_render_handler_win_d3d11.cc
+++ b/tests/cefclient/browser/osr_render_handler_win_d3d11.cc
@@ -35,32 +35,40 @@ PopupLayer::PopupLayer(const std::shared_ptr<d3d11::Device>& device)
 
 void PopupLayer::set_bounds(const CefRect& bounds) {
   const auto comp = composition();
-  if (!comp)
+  if (!comp) {
     return;
+  }
 
   const auto outer_width = comp->width();
   const auto outer_height = comp->height();
-  if (outer_width == 0 || outer_height == 0)
+  if (outer_width == 0 || outer_height == 0) {
     return;
+  }
 
   original_bounds_ = bounds;
   bounds_ = bounds;
 
   // If x or y are negative, move them to 0.
-  if (bounds_.x < 0)
+  if (bounds_.x < 0) {
     bounds_.x = 0;
-  if (bounds_.y < 0)
+  }
+  if (bounds_.y < 0) {
     bounds_.y = 0;
+  }
   // If popup goes outside the view, try to reposition origin
-  if (bounds_.x + bounds_.width > outer_width)
+  if (bounds_.x + bounds_.width > outer_width) {
     bounds_.x = outer_width - bounds_.width;
-  if (bounds_.y + bounds_.height > outer_height)
+  }
+  if (bounds_.y + bounds_.height > outer_height) {
     bounds_.y = outer_height - bounds_.height;
+  }
   // If x or y became negative, move them to 0 again.
-  if (bounds_.x < 0)
+  if (bounds_.x < 0) {
     bounds_.x = 0;
-  if (bounds_.y < 0)
+  }
+  if (bounds_.y < 0) {
     bounds_.y = 0;
+  }
 
   const auto x = bounds_.x / float(outer_width);
   const auto y = bounds_.y / float(outer_height);
@@ -82,14 +90,16 @@ bool OsrRenderHandlerWinD3D11::Initialize(CefRefPtr<CefBrowser> browser,
   // Create a D3D11 device instance.
   device_ = d3d11::Device::create();
   DCHECK(device_);
-  if (!device_)
+  if (!device_) {
     return false;
+  }
 
   // Create a D3D11 swapchain for the window.
   swap_chain_ = device_->create_swapchain(hwnd());
   DCHECK(swap_chain_);
-  if (!swap_chain_)
+  if (!swap_chain_) {
     return false;
+  }
 
   // Create the browser layer.
   browser_layer_ = std::make_shared<BrowserLayer>(device_);
@@ -124,15 +134,17 @@ bool OsrRenderHandlerWinD3D11::IsOverPopupWidget(int x, int y) const {
 
 int OsrRenderHandlerWinD3D11::GetPopupXOffset() const {
   CEF_REQUIRE_UI_THREAD();
-  if (popup_layer_)
+  if (popup_layer_) {
     return popup_layer_->xoffset();
+  }
   return 0;
 }
 
 int OsrRenderHandlerWinD3D11::GetPopupYOffset() const {
   CEF_REQUIRE_UI_THREAD();
-  if (popup_layer_)
+  if (popup_layer_) {
     return popup_layer_->yoffset();
+  }
   return 0;
 }
 
diff --git a/tests/cefclient/browser/osr_renderer.cc b/tests/cefclient/browser/osr_renderer.cc
index 7a55c8fb9..c28044886 100644
--- a/tests/cefclient/browser/osr_renderer.cc
+++ b/tests/cefclient/browser/osr_renderer.cc
@@ -54,8 +54,9 @@ OsrRenderer::~OsrRenderer() {
 }
 
 void OsrRenderer::Initialize() {
-  if (initialized_)
+  if (initialized_) {
     return;
+  }
 
   glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);
   VERIFY_NO_ERROR;
@@ -94,13 +95,15 @@ void OsrRenderer::Initialize() {
 }
 
 void OsrRenderer::Cleanup() {
-  if (texture_id_ != 0)
+  if (texture_id_ != 0) {
     glDeleteTextures(1, &texture_id_);
+  }
 }
 
 void OsrRenderer::Render() {
-  if (view_width_ == 0 || view_height_ == 0)
+  if (view_width_ == 0 || view_height_ == 0) {
     return;
+  }
 
   DCHECK(initialized_);
 
@@ -246,8 +249,9 @@ void OsrRenderer::OnPopupShow(CefRefPtr<CefBrowser> browser, bool show) {
 
 void OsrRenderer::OnPopupSize(CefRefPtr<CefBrowser> browser,
                               const CefRect& rect) {
-  if (rect.width <= 0 || rect.height <= 0)
+  if (rect.width <= 0 || rect.height <= 0) {
     return;
+  }
   original_popup_rect_ = rect;
   popup_rect_ = GetPopupRectInWebView(original_popup_rect_);
 }
@@ -255,20 +259,26 @@ void OsrRenderer::OnPopupSize(CefRefPtr<CefBrowser> browser,
 CefRect OsrRenderer::GetPopupRectInWebView(const CefRect& original_rect) {
   CefRect rc(original_rect);
   // if x or y are negative, move them to 0.
-  if (rc.x < 0)
+  if (rc.x < 0) {
     rc.x = 0;
-  if (rc.y < 0)
+  }
+  if (rc.y < 0) {
     rc.y = 0;
+  }
   // if popup goes outside the view, try to reposition origin
-  if (rc.x + rc.width > view_width_)
+  if (rc.x + rc.width > view_width_) {
     rc.x = view_width_ - rc.width;
-  if (rc.y + rc.height > view_height_)
+  }
+  if (rc.y + rc.height > view_height_) {
     rc.y = view_height_ - rc.height;
+  }
   // if x or y became negative, move them to 0 again.
-  if (rc.x < 0)
+  if (rc.x < 0) {
     rc.x = 0;
-  if (rc.y < 0)
+  }
+  if (rc.y < 0) {
     rc.y = 0;
+  }
   return rc;
 }
 
@@ -283,8 +293,9 @@ void OsrRenderer::OnPaint(CefRefPtr<CefBrowser> browser,
                           const void* buffer,
                           int width,
                           int height) {
-  if (!initialized_)
+  if (!initialized_) {
     Initialize();
+  }
 
   if (IsTransparent()) {
     // Enable alpha blending.
@@ -307,8 +318,9 @@ void OsrRenderer::OnPaint(CefRefPtr<CefBrowser> browser,
     view_width_ = width;
     view_height_ = height;
 
-    if (settings_.show_update_rect)
+    if (settings_.show_update_rect) {
       update_rect_ = dirtyRects[0];
+    }
 
     glPixelStorei(GL_UNPACK_ROW_LENGTH, view_width_);
     VERIFY_NO_ERROR;
@@ -357,10 +369,12 @@ void OsrRenderer::OnPaint(CefRefPtr<CefBrowser> browser,
       skip_rows = -y;
       y = 0;
     }
-    if (x + w > view_width_)
+    if (x + w > view_width_) {
       w -= x + w - view_width_;
-    if (y + h > view_height_)
+    }
+    if (y + h > view_height_) {
       h -= y + h - view_height_;
+    }
 
     // Update the popup rectangle.
     glPixelStorei(GL_UNPACK_ROW_LENGTH, width);
diff --git a/tests/cefclient/browser/osr_window_win.cc b/tests/cefclient/browser/osr_window_win.cc
index cf2404574..913510903 100644
--- a/tests/cefclient/browser/osr_window_win.cc
+++ b/tests/cefclient/browser/osr_window_win.cc
@@ -188,12 +188,14 @@ void OsrWindowWin::Show() {
     return;
   }
 
-  if (!browser_)
+  if (!browser_) {
     return;
+  }
 
   // Show the native window if not currently visible.
-  if (hwnd_ && !::IsWindowVisible(hwnd_))
+  if (hwnd_ && !::IsWindowVisible(hwnd_)) {
     ShowWindow(hwnd_, SW_SHOW);
+  }
 
   if (hidden_) {
     // Set the browser as visible.
@@ -212,8 +214,9 @@ void OsrWindowWin::Hide() {
     return;
   }
 
-  if (!browser_)
+  if (!browser_) {
     return;
+  }
 
   // Remove focus from the browser.
   browser_->GetHost()->SetFocus(false);
@@ -261,8 +264,9 @@ void OsrWindowWin::SetDeviceScaleFactor(float device_scale_factor) {
     return;
   }
 
-  if (device_scale_factor == device_scale_factor_)
+  if (device_scale_factor == device_scale_factor_) {
     return;
+  }
 
   device_scale_factor_ = device_scale_factor;
   if (browser_) {
@@ -318,8 +322,9 @@ void OsrWindowWin::Create(HWND parent_hwnd, const RECT& rect) {
   ime_handler_.reset(new OsrImeHandlerWin(hwnd_));
 
   // Enable Touch Events if requested
-  if (client::MainContext::Get()->TouchEventsEnabled())
+  if (client::MainContext::Get()->TouchEventsEnabled()) {
     RegisterTouchWindow(hwnd_, 0);
+  }
 
   // Notify the window owner.
   NotifyNativeWindowCreated(hwnd_);
@@ -359,8 +364,9 @@ void OsrWindowWin::RegisterOsrClass(HINSTANCE hInstance,
                                     HBRUSH background_brush) {
   // Only register the class one time.
   static bool class_registered = false;
-  if (class_registered)
+  if (class_registered) {
     return;
+  }
   class_registered = true;
 
   WNDCLASSEX wcex;
@@ -458,8 +464,9 @@ LRESULT CALLBACK OsrWindowWin::OsrWndProc(HWND hWnd,
   CEF_REQUIRE_UI_THREAD();
 
   OsrWindowWin* self = GetUserDataPtr<OsrWindowWin*>(hWnd);
-  if (!self)
+  if (!self) {
     return DefWindowProc(hWnd, message, wParam, lParam);
+  }
 
   // We want to handle IME events before the OS does any default handling.
   switch (message) {
@@ -490,8 +497,9 @@ LRESULT CALLBACK OsrWindowWin::OsrWndProc(HWND hWnd,
               static_cast<IAccessible*>(self->accessibility_root_));
         } else {
           // Notify the renderer to enable accessibility.
-          if (self->browser_ && self->browser_->GetHost())
+          if (self->browser_ && self->browser_->GetHost()) {
             self->browser_->GetHost()->SetAccessibilityState(STATE_ENABLED);
+          }
         }
       }
     } break;
@@ -536,8 +544,9 @@ LRESULT CALLBACK OsrWindowWin::OsrWndProc(HWND hWnd,
       return 0;
 
     case WM_ERASEBKGND:
-      if (self->OnEraseBkgnd())
+      if (self->OnEraseBkgnd()) {
         break;
+      }
       // Don't erase the background.
       return 0;
 
@@ -546,8 +555,9 @@ LRESULT CALLBACK OsrWindowWin::OsrWndProc(HWND hWnd,
     // intutive, complete and simpler to code.
     // https://msdn.microsoft.com/en-us/library/hh454903(v=vs.85).aspx
     case WM_TOUCH:
-      if (self->OnTouchEvent(message, wParam, lParam))
+      if (self->OnTouchEvent(message, wParam, lParam)) {
         return 0;
+      }
       break;
 
     case WM_NCDESTROY:
@@ -561,12 +571,14 @@ LRESULT CALLBACK OsrWindowWin::OsrWndProc(HWND hWnd,
 }
 
 void OsrWindowWin::OnMouseEvent(UINT message, WPARAM wParam, LPARAM lParam) {
-  if (IsMouseEventFromTouch(message))
+  if (IsMouseEventFromTouch(message)) {
     return;
+  }
 
   CefRefPtr<CefBrowserHost> browser_host;
-  if (browser_)
+  if (browser_) {
     browser_host = browser_->GetHost();
+  }
 
   LONG currentTime = 0;
   bool cancelPreviousClick = false;
@@ -635,8 +647,9 @@ void OsrWindowWin::OnMouseEvent(UINT message, WPARAM wParam, LPARAM lParam) {
     case WM_LBUTTONUP:
     case WM_RBUTTONUP:
     case WM_MBUTTONUP:
-      if (GetCapture() == hwnd_)
+      if (GetCapture() == hwnd_) {
         ReleaseCapture();
+      }
       if (mouse_rotation_) {
         // End rotation effect.
         mouse_rotation_ = false;
@@ -732,8 +745,9 @@ void OsrWindowWin::OnMouseEvent(UINT message, WPARAM wParam, LPARAM lParam) {
       if (browser_host) {
         POINT screen_point = {GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
         HWND scrolled_wnd = ::WindowFromPoint(screen_point);
-        if (scrolled_wnd != hwnd_)
+        if (scrolled_wnd != hwnd_) {
           break;
+        }
 
         ScreenToClient(hwnd_, &screen_point);
         int delta = GET_WHEEL_DELTA_WPARAM(wParam);
@@ -756,26 +770,31 @@ void OsrWindowWin::OnSize() {
   // Keep |client_rect_| up to date.
   ::GetClientRect(hwnd_, &client_rect_);
 
-  if (browser_)
+  if (browser_) {
     browser_->GetHost()->WasResized();
+  }
 }
 
 void OsrWindowWin::OnFocus(bool setFocus) {
-  if (browser_)
+  if (browser_) {
     browser_->GetHost()->SetFocus(setFocus);
+  }
 }
 
 void OsrWindowWin::OnCaptureLost() {
-  if (mouse_rotation_)
+  if (mouse_rotation_) {
     return;
+  }
 
-  if (browser_)
+  if (browser_) {
     browser_->GetHost()->SendCaptureLostEvent();
+  }
 }
 
 void OsrWindowWin::OnKeyEvent(UINT message, WPARAM wParam, LPARAM lParam) {
-  if (!browser_)
+  if (!browser_) {
     return;
+  }
 
   CefKeyEvent event;
   event.windows_key_code = wParam;
@@ -783,12 +802,13 @@ void OsrWindowWin::OnKeyEvent(UINT message, WPARAM wParam, LPARAM lParam) {
   event.is_system_key = message == WM_SYSCHAR || message == WM_SYSKEYDOWN ||
                         message == WM_SYSKEYUP;
 
-  if (message == WM_KEYDOWN || message == WM_SYSKEYDOWN)
+  if (message == WM_KEYDOWN || message == WM_SYSKEYDOWN) {
     event.type = KEYEVENT_RAWKEYDOWN;
-  else if (message == WM_KEYUP || message == WM_SYSKEYUP)
+  } else if (message == WM_KEYUP || message == WM_SYSKEYUP) {
     event.type = KEYEVENT_KEYUP;
-  else
+  } else {
     event.type = KEYEVENT_CHAR;
+  }
   event.modifiers = GetCefKeyboardModifiers(wParam, lParam);
 
   // mimic alt-gr check behaviour from
@@ -822,8 +842,9 @@ void OsrWindowWin::OnPaint() {
   BeginPaint(hwnd_, &ps);
   EndPaint(hwnd_, &ps);
 
-  if (browser_)
+  if (browser_) {
     browser_->GetHost()->Invalidate(PET_VIEW);
+  }
 }
 
 bool OsrWindowWin::OnEraseBkgnd() {
@@ -835,8 +856,9 @@ bool OsrWindowWin::OnTouchEvent(UINT message, WPARAM wParam, LPARAM lParam) {
   // Handle touch events on Windows.
   int num_points = LOWORD(wParam);
   // Chromium only supports upto 16 touch points.
-  if (num_points < 0 || num_points > 16)
+  if (num_points < 0 || num_points > 16) {
     return false;
+  }
   std::unique_ptr<TOUCHINPUT[]> input(new TOUCHINPUT[num_points]);
   if (GetTouchInputInfo(reinterpret_cast<HTOUCHINPUT>(lParam), num_points,
                         input.get(), sizeof(TOUCHINPUT))) {
@@ -852,8 +874,9 @@ bool OsrWindowWin::OnTouchEvent(UINT message, WPARAM wParam, LPARAM lParam) {
         // ignore touch events in the non-client area.
         LPARAM l_param_ht = MAKELPARAM(point.x, point.y);
         LRESULT hittest = SendMessage(hwnd_, WM_NCHITTEST, 0, l_param_ht);
-        if (hittest != HTCLIENT)
+        if (hittest != HTCLIENT) {
           return false;
+        }
       }
 
       ScreenToClient(hwnd_, &point);
@@ -878,8 +901,9 @@ bool OsrWindowWin::OnTouchEvent(UINT message, WPARAM wParam, LPARAM lParam) {
       touch_event.modifiers = 0;
 
       // Notify the browser of touch event
-      if (browser_)
+      if (browser_) {
         browser_->GetHost()->SendTouchEvent(touch_event);
+      }
     }
     CloseTouchInputHandle(reinterpret_cast<HTOUCHINPUT>(lParam));
     return true;
@@ -889,8 +913,9 @@ bool OsrWindowWin::OnTouchEvent(UINT message, WPARAM wParam, LPARAM lParam) {
 }
 
 bool OsrWindowWin::IsOverPopupWidget(int x, int y) const {
-  if (!render_handler_)
+  if (!render_handler_) {
     return false;
+  }
   return render_handler_->IsOverPopupWidget(x, y);
 }
 
@@ -950,12 +975,14 @@ void OsrWindowWin::GetViewRect(CefRefPtr<CefBrowser> browser, CefRect& rect) {
   rect.x = rect.y = 0;
   rect.width = DeviceToLogical(client_rect_.right - client_rect_.left,
                                device_scale_factor_);
-  if (rect.width == 0)
+  if (rect.width == 0) {
     rect.width = 1;
+  }
   rect.height = DeviceToLogical(client_rect_.bottom - client_rect_.top,
                                 device_scale_factor_);
-  if (rect.height == 0)
+  if (rect.height == 0) {
     rect.height = 1;
+  }
 }
 
 bool OsrWindowWin::GetScreenPoint(CefRefPtr<CefBrowser> browser,
@@ -966,8 +993,9 @@ bool OsrWindowWin::GetScreenPoint(CefRefPtr<CefBrowser> browser,
   CEF_REQUIRE_UI_THREAD();
   DCHECK_GT(device_scale_factor_, 0);
 
-  if (!::IsWindow(hwnd_))
+  if (!::IsWindow(hwnd_)) {
     return false;
+  }
 
   // Convert from view DIP coordinates to screen device (pixel) coordinates.
   POINT screen_pt = {LogicalToDevice(viewX, device_scale_factor_),
@@ -983,8 +1011,9 @@ bool OsrWindowWin::GetScreenInfo(CefRefPtr<CefBrowser> browser,
   CEF_REQUIRE_UI_THREAD();
   DCHECK_GT(device_scale_factor_, 0);
 
-  if (!::IsWindow(hwnd_))
+  if (!::IsWindow(hwnd_)) {
     return false;
+  }
 
   CefRect view_rect;
   GetViewRect(browser, view_rect);
@@ -1033,8 +1062,9 @@ void OsrWindowWin::OnCursorChange(CefRefPtr<CefBrowser> browser,
                                   const CefCursorInfo& custom_cursor_info) {
   CEF_REQUIRE_UI_THREAD();
 
-  if (!::IsWindow(hwnd_))
+  if (!::IsWindow(hwnd_)) {
     return;
+  }
 
   // Change the window's cursor.
   SetClassLongPtr(hwnd_, GCLP_HCURSOR,
@@ -1051,8 +1081,9 @@ bool OsrWindowWin::StartDragging(
   CEF_REQUIRE_UI_THREAD();
 
 #if defined(CEF_USE_ATL)
-  if (!drop_target_)
+  if (!drop_target_) {
     return false;
+  }
 
   current_drag_op_ = DRAG_OPERATION_NONE;
   CefBrowserHost::DragOperationsMask result =
@@ -1153,8 +1184,9 @@ CefBrowserHost::DragOperationsMask OsrWindowWin::OnDragOver(
 }
 
 void OsrWindowWin::OnDragLeave() {
-  if (browser_)
+  if (browser_) {
     browser_->GetHost()->DragTargetDragLeave();
+  }
 }
 
 CefBrowserHost::DragOperationsMask OsrWindowWin::OnDrop(
diff --git a/tests/cefclient/browser/preferences_test.cc b/tests/cefclient/browser/preferences_test.cc
index c202901fe..496e3ef91 100644
--- a/tests/cefclient/browser/preferences_test.cc
+++ b/tests/cefclient/browser/preferences_test.cc
@@ -54,8 +54,9 @@ class Handler : public CefMessageRouterBrowserSide::Handler {
 
     // Only handle messages from the test URL.
     const std::string& url = frame->GetURL();
-    if (!test_runner::IsTestURL(url, kTestUrlPath))
+    if (!test_runner::IsTestURL(url, kTestUrlPath)) {
       return false;
+    }
 
     // Parse |request| as a JSON dictionary.
     CefRefPtr<CefDictionaryValue> request_dict = ParseJSON(request);
@@ -65,16 +66,18 @@ class Handler : public CefMessageRouterBrowserSide::Handler {
     }
 
     // Verify the "name" key.
-    if (!VerifyKey(request_dict, kNameKey, VTYPE_STRING, callback))
+    if (!VerifyKey(request_dict, kNameKey, VTYPE_STRING, callback)) {
       return true;
+    }
 
     const std::string& message_name = request_dict->GetString(kNameKey);
     if (message_name == kNameValueGet) {
       // JavaScript is requesting a JSON representation of the preferences tree.
 
       // Verify the "include_defaults" key.
-      if (!VerifyKey(request_dict, kIncludeDefaultsKey, VTYPE_BOOL, callback))
+      if (!VerifyKey(request_dict, kIncludeDefaultsKey, VTYPE_BOOL, callback)) {
         return true;
+      }
 
       const bool include_defaults = request_dict->GetBool(kIncludeDefaultsKey);
 
@@ -86,8 +89,10 @@ class Handler : public CefMessageRouterBrowserSide::Handler {
       // specified JSON representation.
 
       // Verify the "preferences" key.
-      if (!VerifyKey(request_dict, kPreferencesKey, VTYPE_DICTIONARY, callback))
+      if (!VerifyKey(request_dict, kPreferencesKey, VTYPE_DICTIONARY,
+                     callback)) {
         return true;
+      }
 
       CefRefPtr<CefDictionaryValue> preferences =
           request_dict->GetDictionary(kPreferencesKey);
@@ -147,30 +152,34 @@ class Handler : public CefMessageRouterBrowserSide::Handler {
       ss << "Successfully changed " << changed_names.size() << " preferences; ";
       for (size_t i = 0; i < changed_names.size(); ++i) {
         ss << changed_names[i];
-        if (i < changed_names.size() - 1)
+        if (i < changed_names.size() - 1) {
           ss << ", ";
+        }
       }
       message = ss.str();
     }
 
     if (!success) {
       DCHECK(!error.empty());
-      if (!message.empty())
+      if (!message.empty()) {
         message += "\n";
+      }
       message += error;
     }
 
     if (changed_names.empty()) {
-      if (!message.empty())
+      if (!message.empty()) {
         message += "\n";
+      }
       message += "No preferences changed.";
     }
 
     // Return the message to the JavaScript caller.
-    if (success)
+    if (success) {
       callback->Success(message);
-    else
+    } else {
       callback->Failure(kPreferenceApplicationError, message);
+    }
   }
 
   // Execute |callback| with the global state dictionary as a JSON string.
@@ -206,8 +215,9 @@ class Handler : public CefMessageRouterBrowserSide::Handler {
   // Convert a JSON string to a dictionary value.
   static CefRefPtr<CefDictionaryValue> ParseJSON(const CefString& string) {
     CefRefPtr<CefValue> value = CefParseJSON(string, JSON_PARSER_RFC);
-    if (value.get() && value->GetType() == VTYPE_DICTIONARY)
+    if (value.get() && value->GetType() == VTYPE_DICTIONARY) {
       return value->GetDictionary();
+    }
     return nullptr;
   }
 
@@ -288,10 +298,11 @@ class Handler : public CefMessageRouterBrowserSide::Handler {
       const std::string& string_val = value->GetString();
       switch (existing_value->GetType()) {
         case VTYPE_BOOL:
-          if (string_val == "true" || string_val == "1")
+          if (string_val == "true" || string_val == "1") {
             value->SetBool(true);
-          else if (string_val == "false" || string_val == "0")
+          } else if (string_val == "false" || string_val == "0") {
             value->SetBool(false);
+          }
           break;
         case VTYPE_INT:
           value->SetInt(atoi(string_val.c_str()));
@@ -306,8 +317,9 @@ class Handler : public CefMessageRouterBrowserSide::Handler {
     }
 
     // Nothing to do if the value hasn't changed.
-    if (existing_value->IsEqual(value))
+    if (existing_value->IsEqual(value)) {
       return true;
+    }
 
     // Attempt to set the preference.
     CefString error_str;
diff --git a/tests/cefclient/browser/print_handler_gtk.cc b/tests/cefclient/browser/print_handler_gtk.cc
index c6f333559..bd924c97a 100644
--- a/tests/cefclient/browser/print_handler_gtk.cc
+++ b/tests/cefclient/browser/print_handler_gtk.cc
@@ -87,8 +87,9 @@ class StickyPrintSettingGtk {
 // Lazily initialize the singleton instance.
 StickyPrintSettingGtk* GetLastUsedSettings() {
   static StickyPrintSettingGtk* settings = nullptr;
-  if (!settings)
+  if (!settings) {
     settings = new StickyPrintSettingGtk();
+  }
   return settings;
 }
 
@@ -114,8 +115,9 @@ class GtkPrinterList {
   // - Printer list out of sync with printer dialog UI.
   // - Querying for non-existant printers like 'Print to PDF'.
   GtkPrinter* GetPrinterWithName(const std::string& name) {
-    if (name.empty())
+    if (name.empty()) {
       return nullptr;
+    }
 
     for (std::vector<GtkPrinter*>::iterator it = printers_.begin();
          it < printers_.end(); ++it) {
@@ -131,8 +133,9 @@ class GtkPrinterList {
   // Callback function used by gtk_enumerate_printers() to get all printer.
   static gboolean SetPrinter(GtkPrinter* printer, gpointer data) {
     GtkPrinterList* printer_list = reinterpret_cast<GtkPrinterList*>(data);
-    if (gtk_printer_is_default(printer))
+    if (gtk_printer_is_default(printer)) {
       printer_list->default_printer_ = printer;
+    }
 
     g_object_ref(printer);
     printer_list->printers_.push_back(printer);
@@ -226,8 +229,9 @@ void InitPrintSettings(GtkPrintSettings* settings,
 
   std::string device_name;
   const gchar* name = gtk_print_settings_get_printer(settings);
-  if (name)
+  if (name) {
     device_name = name;
+  }
   print_settings->SetDeviceName(device_name);
 
   CefSize physical_size_device_units;
@@ -278,8 +282,9 @@ void InitPrintSettings(GtkPrintSettings* settings,
 GtkWindow* GetWindow(CefRefPtr<CefBrowser> browser) {
   scoped_refptr<RootWindow> root_window =
       RootWindow::GetForBrowser(browser->GetIdentifier());
-  if (root_window)
+  if (root_window) {
     return GTK_WINDOW(root_window->GetWindowHandle());
+  }
   return nullptr;
 }
 
@@ -386,8 +391,9 @@ struct ClientPrintHandlerGtk::PrintHandler {
         gtk_print_settings_set(gtk_settings_, kCUPSDuplex, cups_duplex_mode);
       }
 
-      if (!page_setup_)
+      if (!page_setup_) {
         page_setup_ = gtk_page_setup_new();
+      }
 
       gtk_print_settings_set_orientation(gtk_settings_,
                                          settings->IsLandscape()
@@ -441,8 +447,9 @@ struct ClientPrintHandlerGtk::PrintHandler {
                   CefRefPtr<CefPrintJobCallback> callback) {
     // If |printer_| is nullptr then somehow the GTK printer list changed out
     // under us. In which case, just bail out.
-    if (!printer_)
+    if (!printer_) {
       return false;
+    }
 
     ScopedGdkThreadsEnter scoped_gdk_threads;
 
@@ -470,19 +477,22 @@ struct ClientPrintHandlerGtk::PrintHandler {
 
     switch (response_id) {
       case GTK_RESPONSE_OK: {
-        if (gtk_settings_)
+        if (gtk_settings_) {
           g_object_unref(gtk_settings_);
+        }
         gtk_settings_ =
             gtk_print_unix_dialog_get_settings(GTK_PRINT_UNIX_DIALOG(dialog_));
 
-        if (printer_)
+        if (printer_) {
           g_object_unref(printer_);
+        }
         printer_ = gtk_print_unix_dialog_get_selected_printer(
             GTK_PRINT_UNIX_DIALOG(dialog_));
         g_object_ref(printer_);
 
-        if (page_setup_)
+        if (page_setup_) {
           g_object_unref(page_setup_);
+        }
         page_setup_ = gtk_print_unix_dialog_get_page_setup(
             GTK_PRINT_UNIX_DIALOG(dialog_));
         g_object_ref(page_setup_);
diff --git a/tests/cefclient/browser/resource_util_linux.cc b/tests/cefclient/browser/resource_util_linux.cc
index a7aa55555..0acdd0969 100644
--- a/tests/cefclient/browser/resource_util_linux.cc
+++ b/tests/cefclient/browser/resource_util_linux.cc
@@ -16,15 +16,17 @@ bool GetResourceDir(std::string& dir) {
 
   // Retrieve the executable path.
   ssize_t len = readlink("/proc/self/exe", buff, sizeof(buff) - 1);
-  if (len == -1)
+  if (len == -1) {
     return false;
+  }
 
   buff[len] = 0;
 
   // Remove the executable name from the path.
   char* pos = strrchr(buff, '/');
-  if (!pos)
+  if (!pos) {
     return false;
+  }
 
   // Add "cefclient_files" to the path.
   strcpy(pos + 1, "cefclient_files");
diff --git a/tests/cefclient/browser/resource_util_win_idmap.cc b/tests/cefclient/browser/resource_util_win_idmap.cc
index 6840f377c..086932c15 100644
--- a/tests/cefclient/browser/resource_util_win_idmap.cc
+++ b/tests/cefclient/browser/resource_util_win_idmap.cc
@@ -49,8 +49,9 @@ int GetResourceId(const char* resource_name) {
                       {"xmlhttprequest.html", IDS_XMLHTTPREQUEST_HTML}};
 
   for (size_t i = 0; i < sizeof(resource_map) / sizeof(_resource_map); ++i) {
-    if (!strcmp(resource_map[i].name, resource_name))
+    if (!strcmp(resource_map[i].name, resource_name)) {
       return resource_map[i].id;
+    }
   }
 
   return 0;
diff --git a/tests/cefclient/browser/response_filter_test.cc b/tests/cefclient/browser/response_filter_test.cc
index b8cab6e1c..70e8f54ac 100644
--- a/tests/cefclient/browser/response_filter_test.cc
+++ b/tests/cefclient/browser/response_filter_test.cc
@@ -43,8 +43,9 @@ class FindReplaceResponseFilter : public CefResponseFilter {
     // Determine a reasonable amount of space for find/replace overflow. For
     // example, the amount of space required if the search string is
     // found/replaced 10 times (plus space for the count).
-    if (replace_size > find_size)
+    if (replace_size > find_size) {
       replace_overflow_size_ = (replace_size - find_size + 3) * 10;
+    }
 
     return true;
   }
@@ -195,8 +196,9 @@ class PassThruResponseFilter : public CefResponseFilter {
 
     // Write out the contents unchanged.
     data_out_written = std::min(data_in_read, data_out_size);
-    if (data_out_written > 0)
+    if (data_out_written > 0) {
       memcpy(data_out, data_in, data_out_written);
+    }
 
     return RESPONSE_FILTER_DONE;
   }
@@ -228,11 +230,13 @@ CefRefPtr<CefResponseFilter> GetResourceResponseFilter(
   // Use the find/replace filter on the test URL.
   const std::string& url = request->GetURL();
 
-  if (test_runner::IsTestURL(url, kTestUrlPath))
+  if (test_runner::IsTestURL(url, kTestUrlPath)) {
     return new FindReplaceResponseFilter();
+  }
 
-  if (MatchesFilterURL(url))
+  if (MatchesFilterURL(url)) {
     return new PassThruResponseFilter();
+  }
 
   return nullptr;
 }
diff --git a/tests/cefclient/browser/root_window.cc b/tests/cefclient/browser/root_window.cc
index 1c2046c62..f2fb4e07d 100644
--- a/tests/cefclient/browser/root_window.cc
+++ b/tests/cefclient/browser/root_window.cc
@@ -28,8 +28,9 @@ void RootWindow::OnExtensionsChanged(const ExtensionSet& extensions) {
   DCHECK(delegate_);
   DCHECK(!WithExtension());
 
-  if (extensions.empty())
+  if (extensions.empty()) {
     return;
+  }
 
   ExtensionSet::const_iterator it = extensions.begin();
   for (; it != extensions.end(); ++it) {
diff --git a/tests/cefclient/browser/root_window_gtk.cc b/tests/cefclient/browser/root_window_gtk.cc
index ff11eaf94..cee0041c9 100644
--- a/tests/cefclient/browser/root_window_gtk.cc
+++ b/tests/cefclient/browser/root_window_gtk.cc
@@ -40,8 +40,9 @@ void UseDefaultX11VisualForGtk(GtkWidget* widget) {
   GList* visuals = gdk_screen_list_visuals(screen);
 
   GdkX11Screen* x11_screen = GDK_X11_SCREEN(screen);
-  if (x11_screen == nullptr)
+  if (x11_screen == nullptr) {
     return;
+  }
 
   Visual* default_xvisual = DefaultVisual(GDK_SCREEN_XDISPLAY(x11_screen),
                                           GDK_SCREEN_XNUMBER(x11_screen));
@@ -67,8 +68,9 @@ bool IsWindowMaximized(GtkWindow* window) {
 
 void MinimizeWindow(GtkWindow* window) {
   // Unmaximize the window before minimizing so restore behaves correctly.
-  if (IsWindowMaximized(window))
+  if (IsWindowMaximized(window)) {
     gtk_window_unmaximize(window);
+  }
 
   gtk_window_iconify(window);
 }
@@ -144,14 +146,18 @@ void RootWindowGtk::InitAsPopup(RootWindow::Delegate* delegate,
   with_osr_ = with_osr;
   is_popup_ = true;
 
-  if (popupFeatures.xSet)
+  if (popupFeatures.xSet) {
     start_rect_.x = popupFeatures.x;
-  if (popupFeatures.ySet)
+  }
+  if (popupFeatures.ySet) {
     start_rect_.y = popupFeatures.y;
-  if (popupFeatures.widthSet)
+  }
+  if (popupFeatures.widthSet) {
     start_rect_.width = popupFeatures.width;
-  if (popupFeatures.heightSet)
+  }
+  if (popupFeatures.heightSet) {
     start_rect_.height = popupFeatures.height;
+  }
 
   CreateBrowserWindow(std::string());
 
@@ -167,8 +173,9 @@ void RootWindowGtk::InitAsPopup(RootWindow::Delegate* delegate,
 void RootWindowGtk::Show(ShowMode mode) {
   REQUIRE_MAIN_THREAD();
 
-  if (!window_)
+  if (!window_) {
     return;
+  }
 
   ScopedGdkThreadsEnter scoped_gdk_threads;
 
@@ -176,10 +183,11 @@ void RootWindowGtk::Show(ShowMode mode) {
   UseDefaultX11VisualForGtk(GTK_WIDGET(window_));
   gtk_widget_show_all(window_);
 
-  if (mode == ShowMinimized)
+  if (mode == ShowMinimized) {
     MinimizeWindow(GTK_WINDOW(window_));
-  else if (mode == ShowMaximized)
+  } else if (mode == ShowMaximized) {
     MaximizeWindow(GTK_WINDOW(window_));
+  }
 
   // Flush the display to make sure the underlying X11 window gets created
   // immediately.
@@ -193,15 +201,17 @@ void RootWindowGtk::Hide() {
 
   ScopedGdkThreadsEnter scoped_gdk_threads;
 
-  if (window_)
+  if (window_) {
     gtk_widget_hide(window_);
+  }
 }
 
 void RootWindowGtk::SetBounds(int x, int y, size_t width, size_t height) {
   REQUIRE_MAIN_THREAD();
 
-  if (!window_)
+  if (!window_) {
     return;
+  }
 
   ScopedGdkThreadsEnter scoped_gdk_threads;
 
@@ -209,10 +219,11 @@ void RootWindowGtk::SetBounds(int x, int y, size_t width, size_t height) {
   GdkWindow* gdk_window = gtk_widget_get_window(window_);
 
   // Make sure the window isn't minimized or maximized.
-  if (IsWindowMaximized(window))
+  if (IsWindowMaximized(window)) {
     gtk_window_unmaximize(window);
-  else
+  } else {
     gtk_window_present(window);
+  }
 
   gdk_window_move_resize(gdk_window, x, y, width, height);
 }
@@ -233,15 +244,17 @@ void RootWindowGtk::Close(bool force) {
 void RootWindowGtk::SetDeviceScaleFactor(float device_scale_factor) {
   REQUIRE_MAIN_THREAD();
 
-  if (browser_window_ && with_osr_)
+  if (browser_window_ && with_osr_) {
     browser_window_->SetDeviceScaleFactor(device_scale_factor);
+  }
 }
 
 float RootWindowGtk::GetDeviceScaleFactor() const {
   REQUIRE_MAIN_THREAD();
 
-  if (browser_window_ && with_osr_)
+  if (browser_window_ && with_osr_) {
     return browser_window_->GetDeviceScaleFactor();
+  }
 
   NOTREACHED();
   return 0.0f;
@@ -250,8 +263,9 @@ float RootWindowGtk::GetDeviceScaleFactor() const {
 CefRefPtr<CefBrowser> RootWindowGtk::GetBrowser() const {
   REQUIRE_MAIN_THREAD();
 
-  if (browser_window_)
+  if (browser_window_) {
     return browser_window_->GetBrowser();
+  }
   return nullptr;
 }
 
@@ -443,8 +457,9 @@ void RootWindowGtk::OnBrowserCreated(CefRefPtr<CefBrowser> browser) {
 
   // For popup browsers create the root window once the browser has been
   // created.
-  if (is_popup_)
+  if (is_popup_) {
     CreateRootWindow(CefBrowserSettings(), false);
+  }
 
   delegate_->OnBrowserCreated(this, browser);
 }
@@ -503,18 +518,20 @@ void RootWindowGtk::OnSetFullscreen(bool fullscreen) {
   if (browser) {
     std::unique_ptr<window_test::WindowTestRunnerGtk> test_runner(
         new window_test::WindowTestRunnerGtk());
-    if (fullscreen)
+    if (fullscreen) {
       test_runner->Maximize(browser);
-    else
+    } else {
       test_runner->Restore(browser);
+    }
   }
 }
 
 void RootWindowGtk::OnAutoResize(const CefSize& new_size) {
   REQUIRE_MAIN_THREAD();
 
-  if (!window_)
+  if (!window_) {
     return;
+  }
 
   ScopedGdkThreadsEnter scoped_gdk_threads;
 
@@ -522,10 +539,11 @@ void RootWindowGtk::OnAutoResize(const CefSize& new_size) {
   GdkWindow* gdk_window = gtk_widget_get_window(window_);
 
   // Make sure the window isn't minimized or maximized.
-  if (IsWindowMaximized(window))
+  if (IsWindowMaximized(window)) {
     gtk_window_unmaximize(window);
-  else
+  } else {
     gtk_window_present(window);
+  }
 
   gdk_window_resize(gdk_window, new_size.width, new_size.height);
 }
@@ -575,8 +593,9 @@ void RootWindowGtk::NotifySetFocus() {
     return;
   }
 
-  if (!browser_window_.get())
+  if (!browser_window_.get()) {
     return;
+  }
 
   browser_window_->SetFocus(true);
   delegate_->OnRootWindowActivated(this);
@@ -589,13 +608,15 @@ void RootWindowGtk::NotifyVisibilityChange(bool show) {
     return;
   }
 
-  if (!browser_window_.get())
+  if (!browser_window_.get()) {
     return;
+  }
 
-  if (show)
+  if (show) {
     browser_window_->Show();
-  else
+  } else {
     browser_window_->Hide();
+  }
 }
 
 void RootWindowGtk::NotifyMenuBarHeight(int height) {
@@ -652,8 +673,9 @@ void RootWindowGtk::NotifyButtonClicked(int id) {
   }
 
   CefRefPtr<CefBrowser> browser = GetBrowser();
-  if (!browser.get())
+  if (!browser.get()) {
     return;
+  }
 
   switch (id) {
     case IDC_NAV_BACK:
@@ -680,8 +702,9 @@ void RootWindowGtk::NotifyMenuItem(int id) {
   }
 
   // Run the test.
-  if (delegate_)
+  if (delegate_) {
     delegate_->OnTest(this, id);
+  }
 }
 
 void RootWindowGtk::NotifyForceClose() {
@@ -717,14 +740,17 @@ void RootWindowGtk::NotifyDestroyedIfDone(bool window_destroyed,
     return;
   }
 
-  if (window_destroyed)
+  if (window_destroyed) {
     window_destroyed_ = true;
-  if (browser_destroyed)
+  }
+  if (browser_destroyed) {
     browser_destroyed_ = true;
+  }
 
   // Notify once both the window and the browser have been destroyed.
-  if (window_destroyed_ && browser_destroyed_)
+  if (window_destroyed_ && browser_destroyed_) {
     delegate_->OnRootWindowDestroyed(this);
+  }
 }
 
 // static
@@ -781,8 +807,9 @@ gboolean RootWindowGtk::WindowDelete(GtkWidget* widget,
   REQUIRE_MAIN_THREAD();
 
   // Called to query whether the root window should be closed.
-  if (self->force_close_)
+  if (self->force_close_) {
     return FALSE;  // Allow the close.
+  }
 
   if (!self->is_closing_) {
     // Notify the browser window that we would like to close it. This
@@ -886,8 +913,9 @@ gboolean RootWindowGtk::URLEntryButtonPress(GtkWidget* widget,
   Atom atoms[2];
   int result =
       XInternAtoms(xdisplay, const_cast<char**>(kAtoms), 2, false, atoms);
-  if (!result)
+  if (!result) {
     NOTREACHED();
+  }
 
   XEvent e;
   e.type = ClientMessage;
diff --git a/tests/cefclient/browser/root_window_mac.mm b/tests/cefclient/browser/root_window_mac.mm
index 30b5e27bb..1b8c8e47b 100644
--- a/tests/cefclient/browser/root_window_mac.mm
+++ b/tests/cefclient/browser/root_window_mac.mm
@@ -74,8 +74,9 @@ std::optional<CefRect> GetWindowBoundsInScreen(NSWindow* window) {
   }
 
   auto screen = [window screen];
-  if (screen == nil)
+  if (screen == nil) {
     screen = [NSScreen mainScreen];
+  }
 
   const auto bounds = [window frame];
   const auto screen_bounds = [screen frame];
@@ -315,14 +316,18 @@ void RootWindowMacImpl::InitAsPopup(RootWindow::Delegate* delegate,
   with_osr_ = with_osr;
   is_popup_ = true;
 
-  if (popupFeatures.xSet)
+  if (popupFeatures.xSet) {
     initial_bounds_.x = popupFeatures.x;
-  if (popupFeatures.ySet)
+  }
+  if (popupFeatures.ySet) {
     initial_bounds_.y = popupFeatures.y;
-  if (popupFeatures.widthSet)
+  }
+  if (popupFeatures.widthSet) {
     initial_bounds_.width = popupFeatures.width;
-  if (popupFeatures.heightSet)
+  }
+  if (popupFeatures.heightSet) {
     initial_bounds_.height = popupFeatures.height;
+  }
 
   CreateBrowserWindow(std::string());
 
@@ -338,8 +343,9 @@ void RootWindowMacImpl::InitAsPopup(RootWindow::Delegate* delegate,
 void RootWindowMacImpl::Show(RootWindow::ShowMode mode) {
   REQUIRE_MAIN_THREAD();
 
-  if (!window_)
+  if (!window_) {
     return;
+  }
 
   const bool is_visible = [window_ isVisible];
   const bool is_minimized = [window_ isMiniaturized];
@@ -353,31 +359,36 @@ void RootWindowMacImpl::Show(RootWindow::ShowMode mode) {
   }
 
   // Undo the previous state since it's not the desired state.
-  if (is_minimized)
+  if (is_minimized) {
     [window_ deminiaturize:nil];
-  else if (is_maximized)
+  } else if (is_maximized) {
     [window_ performZoom:nil];
+  }
 
   // Window visibility may change after (for example) deminiaturizing the
   // window.
-  if (![window_ isVisible])
+  if (![window_ isVisible]) {
     [window_ makeKeyAndOrderFront:nil];
+  }
 
-  if (mode == RootWindow::ShowMinimized)
+  if (mode == RootWindow::ShowMinimized) {
     [window_ performMiniaturize:nil];
-  else if (mode == RootWindow::ShowMaximized)
+  } else if (mode == RootWindow::ShowMaximized) {
     [window_ performZoom:nil];
+  }
 }
 
 void RootWindowMacImpl::Hide() {
   REQUIRE_MAIN_THREAD();
 
-  if (!window_)
+  if (!window_) {
     return;
+  }
 
   // Undo miniaturization, if any, so the window will actually be hidden.
-  if ([window_ isMiniaturized])
+  if ([window_ isMiniaturized]) {
     [window_ deminiaturize:nil];
+  }
 
   // Hide the window.
   [window_ orderOut:nil];
@@ -386,8 +397,9 @@ void RootWindowMacImpl::Hide() {
 void RootWindowMacImpl::SetBounds(int x, int y, size_t width, size_t height) {
   REQUIRE_MAIN_THREAD();
 
-  if (!window_)
+  if (!window_) {
     return;
+  }
 
   const CefRect dip_bounds(x, y, static_cast<int>(width),
                            static_cast<int>(height));
@@ -413,15 +425,17 @@ void RootWindowMacImpl::Close(bool force) {
 void RootWindowMacImpl::SetDeviceScaleFactor(float device_scale_factor) {
   REQUIRE_MAIN_THREAD();
 
-  if (browser_window_ && with_osr_)
+  if (browser_window_ && with_osr_) {
     browser_window_->SetDeviceScaleFactor(device_scale_factor);
+  }
 }
 
 float RootWindowMacImpl::GetDeviceScaleFactor() const {
   REQUIRE_MAIN_THREAD();
 
-  if (browser_window_ && with_osr_)
+  if (browser_window_ && with_osr_) {
     return browser_window_->GetDeviceScaleFactor();
+  }
 
   NOTREACHED();
   return 0.0f;
@@ -430,8 +444,9 @@ float RootWindowMacImpl::GetDeviceScaleFactor() const {
 CefRefPtr<CefBrowser> RootWindowMacImpl::GetBrowser() const {
   REQUIRE_MAIN_THREAD();
 
-  if (browser_window_)
+  if (browser_window_) {
     return browser_window_->GetBrowser();
+  }
   return nullptr;
 }
 
@@ -478,10 +493,12 @@ void RootWindowMacImpl::CreateRootWindow(const CefBrowserSettings& settings,
   CefRect dip_bounds = initial_bounds_;
 
   // TODO(port): Also, maybe there's a better way to choose the default size.
-  if (dip_bounds.width <= 0)
+  if (dip_bounds.width <= 0) {
     dip_bounds.width = 800;
-  if (dip_bounds.height <= 0)
+  }
+  if (dip_bounds.height <= 0) {
     dip_bounds.height = 600;
+  }
 
   // For popups, the requested bounds are for the content area and the requested
   // origin is for the window.
@@ -636,8 +653,9 @@ void RootWindowMacImpl::OnBrowserCreated(CefRefPtr<CefBrowser> browser) {
 
   // For popup browsers create the root window once the browser has been
   // created.
-  if (is_popup_)
+  if (is_popup_) {
     CreateRootWindow(CefBrowserSettings(), false);
+  }
 
   root_window_.delegate_->OnBrowserCreated(&root_window_, browser);
 }
@@ -691,18 +709,20 @@ void RootWindowMacImpl::OnSetFullscreen(bool fullscreen) {
   if (browser) {
     std::unique_ptr<window_test::WindowTestRunnerMac> test_runner(
         new window_test::WindowTestRunnerMac());
-    if (fullscreen)
+    if (fullscreen) {
       test_runner->Maximize(browser);
-    else
+    } else {
       test_runner->Restore(browser);
+    }
   }
 }
 
 void RootWindowMacImpl::OnAutoResize(const CefSize& new_size) {
   REQUIRE_MAIN_THREAD();
 
-  if (!window_)
+  if (!window_) {
     return;
+  }
 
   // Desired content rectangle.
   NSRect content_rect;
@@ -750,8 +770,9 @@ void RootWindowMacImpl::OnSetLoadingState(bool isLoading,
 
 void RootWindowMacImpl::NotifyDestroyedIfDone() {
   // Notify once both the window and the browser have been destroyed.
-  if (window_destroyed_ && browser_destroyed_)
+  if (window_destroyed_ && browser_destroyed_) {
     root_window_.delegate_->OnRootWindowDestroyed(&root_window_);
+  }
 }
 
 RootWindowMac::RootWindowMac() {
@@ -908,40 +929,46 @@ void RootWindowMac::OnNativeWindowClosed() {
 
 - (IBAction)goBack:(id)sender {
   CefRefPtr<CefBrowser> browser = root_window_->GetBrowser();
-  if (browser.get())
+  if (browser.get()) {
     browser->GoBack();
+  }
 }
 
 - (IBAction)goForward:(id)sender {
   CefRefPtr<CefBrowser> browser = root_window_->GetBrowser();
-  if (browser.get())
+  if (browser.get()) {
     browser->GoForward();
+  }
 }
 
 - (IBAction)reload:(id)sender {
   CefRefPtr<CefBrowser> browser = root_window_->GetBrowser();
-  if (browser.get())
+  if (browser.get()) {
     browser->Reload();
+  }
 }
 
 - (IBAction)stopLoading:(id)sender {
   CefRefPtr<CefBrowser> browser = root_window_->GetBrowser();
-  if (browser.get())
+  if (browser.get()) {
     browser->StopLoad();
+  }
 }
 
 - (IBAction)takeURLStringValueFrom:(NSTextField*)sender {
   CefRefPtr<CefBrowser> browser = root_window_->GetBrowser();
-  if (!browser.get())
+  if (!browser.get()) {
     return;
+  }
 
   NSString* url = [sender stringValue];
 
   // if it doesn't already have a prefix, add http. If we can't parse it,
   // just don't bother rather than making things worse.
   NSURL* tempUrl = [NSURL URLWithString:url];
-  if (tempUrl && ![tempUrl scheme])
+  if (tempUrl && ![tempUrl scheme]) {
     url = [@"http://" stringByAppendingString:url];
+  }
 
   std::string urlStr = [url UTF8String];
   browser->GetMainFrame()->LoadURL(urlStr);
@@ -950,30 +977,34 @@ void RootWindowMac::OnNativeWindowClosed() {
 // Called when we are activated (when we gain focus).
 - (void)windowDidBecomeKey:(NSNotification*)notification {
   client::BrowserWindow* browser_window = root_window_->browser_window();
-  if (browser_window)
+  if (browser_window) {
     browser_window->SetFocus(true);
+  }
   root_window_->delegate()->OnRootWindowActivated(root_window_);
 }
 
 // Called when we are deactivated (when we lose focus).
 - (void)windowDidResignKey:(NSNotification*)notification {
   client::BrowserWindow* browser_window = root_window_->browser_window();
-  if (browser_window)
+  if (browser_window) {
     browser_window->SetFocus(false);
+  }
 }
 
 // Called when we have been minimized.
 - (void)windowDidMiniaturize:(NSNotification*)notification {
   client::BrowserWindow* browser_window = root_window_->browser_window();
-  if (browser_window)
+  if (browser_window) {
     browser_window->Hide();
+  }
 }
 
 // Called when we have been unminimized.
 - (void)windowDidDeminiaturize:(NSNotification*)notification {
   client::BrowserWindow* browser_window = root_window_->browser_window();
-  if (browser_window)
+  if (browser_window) {
     browser_window->Show();
+  }
 }
 
 // Called when we have been resized.
@@ -999,8 +1030,9 @@ void RootWindowMac::OnNativeWindowClosed() {
   // If the window is miniaturized then nothing has really changed.
   if (![window_ isMiniaturized]) {
     client::BrowserWindow* browser_window = root_window_->browser_window();
-    if (browser_window)
+    if (browser_window) {
       browser_window->Hide();
+    }
   }
 }
 
@@ -1009,8 +1041,9 @@ void RootWindowMac::OnNativeWindowClosed() {
   // If the window is miniaturized then nothing has really changed.
   if (![window_ isMiniaturized]) {
     client::BrowserWindow* browser_window = root_window_->browser_window();
-    if (browser_window)
+    if (browser_window) {
       browser_window->Show();
+    }
   }
 }
 
diff --git a/tests/cefclient/browser/root_window_manager.cc b/tests/cefclient/browser/root_window_manager.cc
index cfbc4a338..303ca3724 100644
--- a/tests/cefclient/browser/root_window_manager.cc
+++ b/tests/cefclient/browser/root_window_manager.cc
@@ -52,8 +52,9 @@ class ClientRequestContextHandler : public CefRequestContextHandler,
         std::string part;
         std::istringstream f(extension_path);
         while (getline(f, part, ';')) {
-          if (!part.empty())
+          if (!part.empty()) {
             extension_util::LoadExtension(request_context, part, this);
+          }
         }
       }
     }
@@ -190,18 +191,21 @@ bool RootWindowManager::HasRootWindowAsExtension(
   REQUIRE_MAIN_THREAD();
 
   for (auto root_window : root_windows_) {
-    if (!root_window->WithExtension())
+    if (!root_window->WithExtension()) {
       continue;
+    }
 
     CefRefPtr<CefBrowser> browser = root_window->GetBrowser();
-    if (!browser)
+    if (!browser) {
       continue;
+    }
 
     CefRefPtr<CefExtension> browser_extension =
         browser->GetHost()->GetExtension();
     DCHECK(browser_extension);
-    if (browser_extension->GetIdentifier() == extension->GetIdentifier())
+    if (browser_extension->GetIdentifier() == extension->GetIdentifier()) {
       return true;
+    }
   }
 
   return false;
@@ -213,8 +217,9 @@ scoped_refptr<RootWindow> RootWindowManager::GetWindowForBrowser(
 
   for (auto root_window : root_windows_) {
     CefRefPtr<CefBrowser> browser = root_window->GetBrowser();
-    if (browser.get() && browser->GetIdentifier() == browser_id)
+    if (browser.get() && browser->GetIdentifier() == browser_id) {
       return root_window;
+    }
   }
   return nullptr;
 }
@@ -237,8 +242,9 @@ void RootWindowManager::CloseAllWindows(bool force) {
     return;
   }
 
-  if (root_windows_.empty())
+  if (root_windows_.empty()) {
     return;
+  }
 
   // Use a copy of |root_windows_| because the original set may be modified
   // in OnRootWindowDestroyed while iterating.
@@ -258,14 +264,16 @@ void RootWindowManager::AddExtension(CefRefPtr<CefExtension> extension) {
   }
 
   // Don't track extensions that can't be loaded directly.
-  if (extension_util::GetExtensionURL(extension).empty())
+  if (extension_util::GetExtensionURL(extension).empty()) {
     return;
+  }
 
   // Don't add the same extension multiple times.
   ExtensionSet::const_iterator it = extensions_.begin();
   for (; it != extensions_.end(); ++it) {
-    if ((*it)->GetIdentifier() == extension->GetIdentifier())
+    if ((*it)->GetIdentifier() == extension->GetIdentifier()) {
       return;
+    }
   }
 
   extensions_.insert(extension);
@@ -297,8 +305,9 @@ void RootWindowManager::NotifyExtensionsChanged() {
   REQUIRE_MAIN_THREAD();
 
   for (auto root_window : root_windows_) {
-    if (!root_window->WithExtension())
+    if (!root_window->WithExtension()) {
       root_window->OnExtensionsChanged(extensions_);
+    }
   }
 }
 
@@ -366,8 +375,9 @@ void RootWindowManager::OnRootWindowDestroyed(RootWindow* root_window) {
 
   RootWindowSet::iterator it = root_windows_.find(root_window);
   DCHECK(it != root_windows_.end());
-  if (it != root_windows_.end())
+  if (it != root_windows_.end()) {
     root_windows_.erase(it);
+  }
 
   if (root_window == active_root_window_) {
     active_root_window_ = nullptr;
@@ -391,8 +401,9 @@ void RootWindowManager::OnRootWindowActivated(RootWindow* root_window) {
     return;
   }
 
-  if (root_window == active_root_window_)
+  if (root_window == active_root_window_) {
     return;
+  }
 
   active_root_window_ = root_window;
 
diff --git a/tests/cefclient/browser/root_window_views.cc b/tests/cefclient/browser/root_window_views.cc
index 0c51c6e41..973a81c8b 100644
--- a/tests/cefclient/browser/root_window_views.cc
+++ b/tests/cefclient/browser/root_window_views.cc
@@ -62,14 +62,18 @@ void RootWindowViews::InitAsPopup(RootWindow::Delegate* delegate,
   config_ = std::make_unique<RootWindowConfig>();
   config_->with_controls = with_controls;
 
-  if (popupFeatures.xSet)
+  if (popupFeatures.xSet) {
     initial_bounds_.x = popupFeatures.x;
-  if (popupFeatures.ySet)
+  }
+  if (popupFeatures.ySet) {
     initial_bounds_.y = popupFeatures.y;
-  if (popupFeatures.widthSet)
+  }
+  if (popupFeatures.widthSet) {
     initial_bounds_.width = popupFeatures.width;
-  if (popupFeatures.heightSet)
+  }
+  if (popupFeatures.heightSet) {
     initial_bounds_.height = popupFeatures.height;
+  }
 
   CreateClientHandler(std::string());
   initialized_ = true;
@@ -85,8 +89,9 @@ void RootWindowViews::Show(ShowMode mode) {
     return;
   }
 
-  if (!window_)
+  if (!window_) {
     return;
+  }
 
   window_->Show();
 
@@ -109,8 +114,9 @@ void RootWindowViews::Hide() {
     return;
   }
 
-  if (window_)
+  if (window_) {
     window_->Hide();
+  }
 }
 
 void RootWindowViews::SetBounds(int x, int y, size_t width, size_t height) {
@@ -134,8 +140,9 @@ void RootWindowViews::Close(bool force) {
     return;
   }
 
-  if (window_)
+  if (window_) {
     window_->Close(force);
+  }
 }
 
 void RootWindowViews::SetDeviceScaleFactor(float device_scale_factor) {
@@ -162,8 +169,9 @@ ClientWindowHandle RootWindowViews::GetWindowHandle() const {
   // ClientWindowHandle is a GtkWidget* on Linux and we don't have one of those.
   return nullptr;
 #else
-  if (browser_)
+  if (browser_) {
     return browser_->GetHost()->GetWindowHandle();
+  }
   return kNullWindowHandle;
 #endif
 }
@@ -351,8 +359,9 @@ void RootWindowViews::OnSetAddress(const std::string& url) {
     return;
   }
 
-  if (window_)
+  if (window_) {
     window_->SetAddress(url);
+  }
 }
 
 void RootWindowViews::OnSetTitle(const std::string& title) {
@@ -363,8 +372,9 @@ void RootWindowViews::OnSetTitle(const std::string& title) {
     return;
   }
 
-  if (window_)
+  if (window_) {
     window_->SetTitle(title);
+  }
 }
 
 void RootWindowViews::OnSetFavicon(CefRefPtr<CefImage> image) {
@@ -375,8 +385,9 @@ void RootWindowViews::OnSetFavicon(CefRefPtr<CefImage> image) {
     return;
   }
 
-  if (window_)
+  if (window_) {
     window_->SetFavicon(image);
+  }
 }
 
 void RootWindowViews::OnSetFullscreen(bool fullscreen) {
@@ -387,8 +398,9 @@ void RootWindowViews::OnSetFullscreen(bool fullscreen) {
     return;
   }
 
-  if (window_)
+  if (window_) {
     window_->SetFullscreen(fullscreen);
+  }
 }
 
 void RootWindowViews::OnAutoResize(const CefSize& new_size) {
@@ -449,8 +461,9 @@ void RootWindowViews::OnSetDraggableRegions(
     return;
   }
 
-  if (window_)
+  if (window_) {
     window_->SetDraggableRegions(regions);
+  }
 }
 
 void RootWindowViews::OnTakeFocus(bool next) {
@@ -461,14 +474,16 @@ void RootWindowViews::OnTakeFocus(bool next) {
     return;
   }
 
-  if (window_)
+  if (window_) {
     window_->TakeFocus(next);
+  }
 }
 
 void RootWindowViews::OnBeforeContextMenu(CefRefPtr<CefMenuModel> model) {
   CEF_REQUIRE_UI_THREAD();
-  if (window_)
+  if (window_) {
     window_->OnBeforeContextMenu(model);
+  }
 }
 
 void RootWindowViews::CreateClientHandler(const std::string& url) {
@@ -510,8 +525,9 @@ void RootWindowViews::InitOnUIThread(
 
   // Populate the default image cache.
   ImageCache::ImageInfoSet image_set;
-  for (size_t i = 0U; i < std::size(kDefaultImageCache); ++i)
+  for (size_t i = 0U; i < std::size(kDefaultImageCache); ++i) {
     image_set.push_back(ImageCache::ImageInfo::Create2x(kDefaultImageCache[i]));
+  }
 
   image_cache_->LoadImages(
       image_set, base::BindOnce(&RootWindowViews::CreateViewsWindow, this,
@@ -557,8 +573,9 @@ void RootWindowViews::NotifyDestroyedIfDone() {
     scoped_refptr<RootWindow> self = this;
 
     delegate_->OnRootWindowDestroyed(this);
-    if (!config_->close_callback.is_null())
+    if (!config_->close_callback.is_null()) {
       std::move(config_->close_callback).Run();
+    }
   }
 }
 
diff --git a/tests/cefclient/browser/root_window_win.cc b/tests/cefclient/browser/root_window_win.cc
index 493f39b5d..1a03cf229 100644
--- a/tests/cefclient/browser/root_window_win.cc
+++ b/tests/cefclient/browser/root_window_win.cc
@@ -72,8 +72,9 @@ bool IsProcessPerMonitorDpiAware() {
       if (func_ptr) {
         PROCESS_DPI_AWARENESS awareness;
         if (SUCCEEDED(func_ptr(nullptr, &awareness)) &&
-            awareness == PROCESS_PER_MONITOR_DPI_AWARE)
+            awareness == PROCESS_PER_MONITOR_DPI_AWARE) {
           per_monitor_dpi_aware = PerMonitorDpiAware::PER_MONITOR_DPI_AWARE;
+        }
       }
     }
   }
@@ -88,8 +89,9 @@ float GetWindowScaleFactor(HWND hwnd) {
     typedef UINT(WINAPI * GetDpiForWindowPtr)(HWND);
     static GetDpiForWindowPtr func_ptr = reinterpret_cast<GetDpiForWindowPtr>(
         GetProcAddress(GetModuleHandle(L"user32.dll"), "GetDpiForWindow"));
-    if (func_ptr)
+    if (func_ptr) {
       return static_cast<float>(func_ptr(hwnd)) / DPI_1X;
+    }
   }
 
   return client::GetDeviceScaleFactor();
@@ -193,14 +195,18 @@ void RootWindowWin::InitAsPopup(RootWindow::Delegate* delegate,
   with_osr_ = with_osr;
   is_popup_ = true;
 
-  if (popupFeatures.xSet)
+  if (popupFeatures.xSet) {
     initial_bounds_.x = popupFeatures.x;
-  if (popupFeatures.ySet)
+  }
+  if (popupFeatures.ySet) {
     initial_bounds_.y = popupFeatures.y;
-  if (popupFeatures.widthSet)
+  }
+  if (popupFeatures.widthSet) {
     initial_bounds_.width = popupFeatures.width;
-  if (popupFeatures.heightSet)
+  }
+  if (popupFeatures.heightSet) {
     initial_bounds_.height = popupFeatures.height;
+  }
 
   CreateBrowserWindow(std::string());
 
@@ -216,8 +222,9 @@ void RootWindowWin::InitAsPopup(RootWindow::Delegate* delegate,
 void RootWindowWin::Show(ShowMode mode) {
   REQUIRE_MAIN_THREAD();
 
-  if (!hwnd_)
+  if (!hwnd_) {
     return;
+  }
 
   int nCmdShow = SW_SHOWNORMAL;
   switch (mode) {
@@ -235,15 +242,17 @@ void RootWindowWin::Show(ShowMode mode) {
   }
 
   ShowWindow(hwnd_, nCmdShow);
-  if (mode != ShowMinimized)
+  if (mode != ShowMinimized) {
     UpdateWindow(hwnd_);
+  }
 }
 
 void RootWindowWin::Hide() {
   REQUIRE_MAIN_THREAD();
 
-  if (hwnd_)
+  if (hwnd_) {
     ShowWindow(hwnd_, SW_HIDE);
+  }
 }
 
 void RootWindowWin::SetBounds(int x, int y, size_t width, size_t height) {
@@ -259,25 +268,28 @@ void RootWindowWin::Close(bool force) {
   REQUIRE_MAIN_THREAD();
 
   if (hwnd_) {
-    if (force)
+    if (force) {
       DestroyWindow(hwnd_);
-    else
+    } else {
       PostMessage(hwnd_, WM_CLOSE, 0, 0);
+    }
   }
 }
 
 void RootWindowWin::SetDeviceScaleFactor(float device_scale_factor) {
   REQUIRE_MAIN_THREAD();
 
-  if (browser_window_ && with_osr_)
+  if (browser_window_ && with_osr_) {
     browser_window_->SetDeviceScaleFactor(device_scale_factor);
+  }
 }
 
 float RootWindowWin::GetDeviceScaleFactor() const {
   REQUIRE_MAIN_THREAD();
 
-  if (browser_window_ && with_osr_)
+  if (browser_window_ && with_osr_) {
     return browser_window_->GetDeviceScaleFactor();
+  }
 
   NOTREACHED();
   return 0.0f;
@@ -286,8 +298,9 @@ float RootWindowWin::GetDeviceScaleFactor() const {
 CefRefPtr<CefBrowser> RootWindowWin::GetBrowser() const {
   REQUIRE_MAIN_THREAD();
 
-  if (browser_window_)
+  if (browser_window_) {
     return browser_window_->GetBrowser();
+  }
   return nullptr;
 }
 
@@ -393,8 +406,9 @@ void RootWindowWin::CreateRootWindow(const CefBrowserSettings& settings,
     static EnableChildWindowDpiMessagePtr func_ptr =
         reinterpret_cast<EnableChildWindowDpiMessagePtr>(GetProcAddress(
             GetModuleHandle(L"user32.dll"), "EnableChildWindowDpiMessage"));
-    if (func_ptr)
+    if (func_ptr) {
       func_ptr(hwnd_, TRUE);
+    }
   }
 
   if (!initially_hidden) {
@@ -418,8 +432,9 @@ void RootWindowWin::RegisterRootClass(HINSTANCE hInstance,
                                       HBRUSH background_brush) {
   // Only register the class one time.
   static bool class_registered = false;
-  if (class_registered)
+  if (class_registered) {
     return;
+  }
   class_registered = true;
 
   WNDCLASSEX wcex;
@@ -516,8 +531,9 @@ LRESULT CALLBACK RootWindowWin::RootWndProc(HWND hWnd,
   RootWindowWin* self = nullptr;
   if (message != WM_NCCREATE) {
     self = GetUserDataPtr<RootWindowWin*>(hWnd);
-    if (!self)
+    if (!self) {
       return DefWindowProc(hWnd, message, wParam, lParam);
+    }
     DCHECK_EQ(hWnd, self->hwnd_);
   }
 
@@ -532,8 +548,9 @@ LRESULT CALLBACK RootWindowWin::RootWndProc(HWND hWnd,
   // Callback for the main window
   switch (message) {
     case WM_COMMAND:
-      if (self->OnCommand(LOWORD(wParam)))
+      if (self->OnCommand(LOWORD(wParam))) {
         return 0;
+      }
       break;
 
     case WM_GETOBJECT: {
@@ -543,8 +560,9 @@ LRESULT CALLBACK RootWindowWin::RootWndProc(HWND hWnd,
 
       // Accessibility readers will send an OBJID_CLIENT message.
       if (static_cast<DWORD>(OBJID_CLIENT) == obj_id) {
-        if (self->GetBrowser() && self->GetBrowser()->GetHost())
+        if (self->GetBrowser() && self->GetBrowser()->GetHost()) {
           self->GetBrowser()->GetHost()->SetAccessibilityState(STATE_ENABLED);
+        }
       }
     } break;
 
@@ -584,8 +602,9 @@ LRESULT CALLBACK RootWindowWin::RootWndProc(HWND hWnd,
       break;
 
     case WM_ERASEBKGND:
-      if (self->OnEraseBkgnd())
+      if (self->OnEraseBkgnd()) {
         break;
+      }
       // Don't erase the background.
       return 0;
 
@@ -604,8 +623,9 @@ LRESULT CALLBACK RootWindowWin::RootWndProc(HWND hWnd,
       break;
 
     case WM_CLOSE:
-      if (self->OnClose())
+      if (self->OnClose()) {
         return 0;  // Cancel the close.
+      }
       break;
 
     case WM_NCHITTEST: {
@@ -659,25 +679,29 @@ void RootWindowWin::OnFocus() {
   // Selecting "Close window" from the task bar menu may send a focus
   // notification even though the window is currently disabled (e.g. while a
   // modal JS dialog is displayed).
-  if (browser_window_ && ::IsWindowEnabled(hwnd_))
+  if (browser_window_ && ::IsWindowEnabled(hwnd_)) {
     browser_window_->SetFocus(true);
+  }
 }
 
 void RootWindowWin::OnActivate(bool active) {
-  if (active)
+  if (active) {
     delegate_->OnRootWindowActivated(this);
+  }
 }
 
 void RootWindowWin::OnSize(bool minimized) {
   if (minimized) {
     // Notify the browser window that it was hidden and do nothing further.
-    if (browser_window_)
+    if (browser_window_) {
       browser_window_->Hide();
+    }
     return;
   }
 
-  if (browser_window_)
+  if (browser_window_) {
     browser_window_->Show();
+  }
 
   RECT rect;
   GetClientRect(hwnd_, &rect);
@@ -718,8 +742,9 @@ void RootWindowWin::OnSize(bool minimized) {
 
     // |browser_hwnd| may be nullptr if the browser has not yet been created.
     HWND browser_hwnd = nullptr;
-    if (browser_window_)
+    if (browser_window_) {
       browser_hwnd = browser_window_->GetWindowHandle();
+    }
 
     // Resize all controls.
     HDWP hdwp = BeginDeferWindowPos(browser_hwnd ? 6 : 5);
@@ -756,8 +781,9 @@ void RootWindowWin::OnMove() {
   // Notify the browser of move events so that popup windows are displayed
   // in the correct location and dismissed when the window moves.
   CefRefPtr<CefBrowser> browser = GetBrowser();
-  if (browser)
+  if (browser) {
     browser->GetHost()->NotifyMoveOrResizeStarted();
+  }
 }
 
 void RootWindowWin::OnDpiChanged(WPARAM wParam, LPARAM lParam) {
@@ -801,20 +827,24 @@ bool RootWindowWin::OnCommand(UINT id) {
       OnFind();
       return true;
     case IDC_NAV_BACK:  // Back button
-      if (CefRefPtr<CefBrowser> browser = GetBrowser())
+      if (CefRefPtr<CefBrowser> browser = GetBrowser()) {
         browser->GoBack();
+      }
       return true;
     case IDC_NAV_FORWARD:  // Forward button
-      if (CefRefPtr<CefBrowser> browser = GetBrowser())
+      if (CefRefPtr<CefBrowser> browser = GetBrowser()) {
         browser->GoForward();
+      }
       return true;
     case IDC_NAV_RELOAD:  // Reload button
-      if (CefRefPtr<CefBrowser> browser = GetBrowser())
+      if (CefRefPtr<CefBrowser> browser = GetBrowser()) {
         browser->Reload();
+      }
       return true;
     case IDC_NAV_STOP:  // Stop button
-      if (CefRefPtr<CefBrowser> browser = GetBrowser())
+      if (CefRefPtr<CefBrowser> browser = GetBrowser()) {
         browser->StopLoad();
+      }
       return true;
   }
 
@@ -874,8 +904,9 @@ void RootWindowWin::OnFindEvent() {
     browser->GetHost()->Find(find_what,
                              (find_state_.Flags & FR_DOWN) ? true : false,
                              match_case, find_next_);
-    if (!find_next_)
+    if (!find_next_) {
       find_next_ = true;
+    }
   }
 }
 
@@ -1060,15 +1091,17 @@ void RootWindowWin::OnBrowserWindowDestroyed() {
 void RootWindowWin::OnSetAddress(const std::string& url) {
   REQUIRE_MAIN_THREAD();
 
-  if (edit_hwnd_)
+  if (edit_hwnd_) {
     SetWindowText(edit_hwnd_, CefString(url).ToWString().c_str());
+  }
 }
 
 void RootWindowWin::OnSetTitle(const std::string& title) {
   REQUIRE_MAIN_THREAD();
 
-  if (hwnd_)
+  if (hwnd_) {
     SetWindowText(hwnd_, CefString(title).ToWString().c_str());
+  }
 }
 
 void RootWindowWin::OnSetFullscreen(bool fullscreen) {
@@ -1078,24 +1111,27 @@ void RootWindowWin::OnSetFullscreen(bool fullscreen) {
   if (browser) {
     std::unique_ptr<window_test::WindowTestRunnerWin> test_runner(
         new window_test::WindowTestRunnerWin());
-    if (fullscreen)
+    if (fullscreen) {
       test_runner->Maximize(browser);
-    else
+    } else {
       test_runner->Restore(browser);
+    }
   }
 }
 
 void RootWindowWin::OnAutoResize(const CefSize& new_size) {
   REQUIRE_MAIN_THREAD();
 
-  if (!hwnd_)
+  if (!hwnd_) {
     return;
+  }
 
   int new_width = new_size.width;
 
   // Make the window wide enough to drag by the top menu bar.
-  if (new_width < 200)
+  if (new_width < 200) {
     new_width = 200;
+  }
 
   const float device_scale_factor = GetWindowScaleFactor(hwnd_);
   RECT rect = {0, 0, LogicalToDevice(new_width, device_scale_factor),
@@ -1249,8 +1285,9 @@ void RootWindowWin::OnSetDraggableRegions(
 
 void RootWindowWin::NotifyDestroyedIfDone() {
   // Notify once both the window and the browser have been destroyed.
-  if (window_destroyed_ && browser_destroyed_)
+  if (window_destroyed_ && browser_destroyed_) {
     delegate_->OnRootWindowDestroyed(this);
+  }
 }
 
 // static
diff --git a/tests/cefclient/browser/server_test.cc b/tests/cefclient/browser/server_test.cc
index e57e9f304..967605491 100644
--- a/tests/cefclient/browser/server_test.cc
+++ b/tests/cefclient/browser/server_test.cc
@@ -93,11 +93,13 @@ class ServerHandler : public CefServerHandler {
     CefURLParts url_parts;
     CefParseURL(request->GetURL(), url_parts);
     std::string path = CefString(&url_parts.path);
-    if (!path.empty() && path[0] == '/')
+    if (!path.empty() && path[0] == '/') {
       path = path.substr(1);
+    }
 
-    if (path.empty())
+    if (path.empty()) {
       path = kDefaultPath;
+    }
 
     std::string mime_type;
     const size_t sep = path.find_last_of(".");
@@ -108,8 +110,9 @@ class ServerHandler : public CefServerHandler {
       // No extension. Assume html.
       path += ".html";
     }
-    if (mime_type.empty())
+    if (mime_type.empty()) {
       mime_type = "text/html";
+    }
 
     CefRefPtr<CefStreamReader> stream;
     CefResponse::HeaderMap extra_headers;
@@ -189,8 +192,9 @@ class ServerHandler : public CefServerHandler {
     size_t read;
     do {
       read = stream->Read(buffer, 1, sizeof(buffer));
-      if (read > 0)
+      if (read > 0) {
         server->SendRawData(connection_id, buffer, read);
+      }
     } while (!stream->Eof() && read != 0);
 
     // Close the connection.
@@ -230,8 +234,9 @@ class Handler : public CefMessageRouterBrowserSide::Handler {
 
     // Only handle messages from the test URL.
     const std::string& url = frame->GetURL();
-    if (url.find(kTestUrl) != 0)
+    if (url.find(kTestUrl) != 0) {
       return false;
+    }
 
     // Parse |request| as a JSON dictionary.
     CefRefPtr<CefDictionaryValue> request_dict = ParseJSON(request);
@@ -240,8 +245,9 @@ class Handler : public CefMessageRouterBrowserSide::Handler {
       return true;
     }
 
-    if (!VerifyKey(request_dict, kActionKey, VTYPE_STRING, callback))
+    if (!VerifyKey(request_dict, kActionKey, VTYPE_STRING, callback)) {
       return true;
+    }
 
     const std::string& action = request_dict->GetString(kActionKey);
     if (action == "query") {
@@ -280,8 +286,9 @@ class Handler : public CefMessageRouterBrowserSide::Handler {
       return;
     }
 
-    if (!VerifyKey(request_dict, kPortKey, VTYPE_INT, callback))
+    if (!VerifyKey(request_dict, kPortKey, VTYPE_INT, callback)) {
       return;
+    }
 
     const int port = request_dict->GetInt(kPortKey);
     if (port < 8000 || port > 65535) {
@@ -350,8 +357,9 @@ class Handler : public CefMessageRouterBrowserSide::Handler {
   // Convert a JSON string to a dictionary value.
   static CefRefPtr<CefDictionaryValue> ParseJSON(const CefString& string) {
     CefRefPtr<CefValue> value = CefParseJSON(string, JSON_PARSER_RFC);
-    if (value.get() && value->GetType() == VTYPE_DICTIONARY)
+    if (value.get() && value->GetType() == VTYPE_DICTIONARY) {
       return value->GetDictionary();
+    }
     return nullptr;
   }
 
diff --git a/tests/cefclient/browser/test_runner.cc b/tests/cefclient/browser/test_runner.cc
index 5833976ef..0bb292766 100644
--- a/tests/cefclient/browser/test_runner.cc
+++ b/tests/cefclient/browser/test_runner.cc
@@ -173,23 +173,26 @@ class PromptHandler : public CefMessageRouterBrowserSide::Handler {
                        CefRefPtr<Callback> callback) override {
     // Parse |request| which takes the form "Prompt.[type]:[value]".
     const std::string& request_str = request;
-    if (request_str.find(kPrompt) != 0)
+    if (request_str.find(kPrompt) != 0) {
       return false;
+    }
 
     std::string type = request_str.substr(sizeof(kPrompt) - 1);
     size_t delim = type.find(':');
-    if (delim == std::string::npos)
+    if (delim == std::string::npos) {
       return false;
+    }
 
     const std::string& value = type.substr(delim + 1);
     type = type.substr(0, delim);
 
     // Canceling the prompt dialog returns a value of "null".
     if (value != "null") {
-      if (type == kPromptFPS)
+      if (type == kPromptFPS) {
         SetFPS(browser, atoi(value.c_str()));
-      else if (type == kPromptDSF)
+      } else if (type == kPromptDSF) {
         SetDSF(browser, static_cast<float>(atof(value.c_str())));
+      }
     }
 
     // Nothing is done with the response.
@@ -290,8 +293,9 @@ void EndTracing(CefRefPtr<CefBrowser> browser) {
     void RunDialog() {
       static const char kDefaultFileName[] = "trace.txt";
       std::string path = MainContext::Get()->GetDownloadPath(kDefaultFileName);
-      if (path.empty())
+      if (path.empty()) {
         path = kDefaultFileName;
+      }
 
       // Results in a call to OnFileDialogDismissed.
       browser_->GetHost()->RunFileDialog(
@@ -341,8 +345,9 @@ void PrintToPDF(CefRefPtr<CefBrowser> browser) {
     void RunDialog() {
       static const char kDefaultFileName[] = "output.pdf";
       std::string path = MainContext::Get()->GetDownloadPath(kDefaultFileName);
-      if (path.empty())
+      if (path.empty()) {
         path = kDefaultFileName;
+      }
 
       std::vector<CefString> accept_filters;
       accept_filters.push_back(".pdf");
@@ -492,8 +497,9 @@ std::string RequestUrlFilter(const std::string& url) {
 
   // Identify where the query or fragment component, if any, begins.
   size_t suffix_pos = url.find('?');
-  if (suffix_pos == std::string::npos)
+  if (suffix_pos == std::string::npos) {
     suffix_pos = url.find('#');
+  }
 
   std::string url_base, url_suffix;
   if (suffix_pos == std::string::npos) {
@@ -505,15 +511,17 @@ std::string RequestUrlFilter(const std::string& url) {
 
   // Identify the last path component.
   size_t path_pos = url_base.rfind('/');
-  if (path_pos == std::string::npos)
+  if (path_pos == std::string::npos) {
     return url;
+  }
 
   const std::string& path_component = url_base.substr(path_pos);
 
   // Identify if a file extension is currently specified.
   size_t ext_pos = path_component.rfind(".");
-  if (ext_pos != std::string::npos)
+  if (ext_pos != std::string::npos) {
     return url;
+  }
 
   // Rebuild the URL with a file extension.
   return url_base + ".html" + url_suffix;
@@ -522,8 +530,9 @@ std::string RequestUrlFilter(const std::string& url) {
 }  // namespace
 
 void RunTest(CefRefPtr<CefBrowser> browser, int id) {
-  if (!browser)
+  if (!browser) {
     return;
+  }
 
   switch (id) {
     case ID_TESTS_GETSOURCE:
@@ -789,8 +798,9 @@ void Alert(CefRefPtr<CefBrowser> browser, const std::string& message) {
     // Alerts originating from extension hosts should instead be displayed in
     // the active browser.
     browser = MainContext::Get()->GetRootWindowManager()->GetActiveBrowser();
-    if (!browser)
+    if (!browser) {
       return;
+    }
   }
 
   // Escape special characters in the message.
@@ -807,8 +817,9 @@ bool IsTestURL(const std::string& url, const std::string& path) {
   CefParseURL(url, parts);
 
   const std::string& url_host = CefString(&parts.host);
-  if (url_host != kTestHost && url_host != kLocalHost)
+  if (url_host != kTestHost && url_host != kLocalHost) {
     return false;
+  }
 
   const std::string& url_path = CefString(&parts.path);
   return url_path.find(path) == 0;
diff --git a/tests/cefclient/browser/text_input_client_osr_mac.h b/tests/cefclient/browser/text_input_client_osr_mac.h
index 9f6cbca6c..def6d5556 100644
--- a/tests/cefclient/browser/text_input_client_osr_mac.h
+++ b/tests/cefclient/browser/text_input_client_osr_mac.h
@@ -16,7 +16,7 @@
 // Implementation for the NSTextInputClient protocol used for enabling IME on
 // mac when window rendering is disabled.
 
-@interface CefTextInputClientOSRMac : NSObject<NSTextInputClient> {
+@interface CefTextInputClientOSRMac : NSObject <NSTextInputClient> {
  @private
 
   // The range of current marked text inside the whole content of the DOM node
diff --git a/tests/cefclient/browser/text_input_client_osr_mac.mm b/tests/cefclient/browser/text_input_client_osr_mac.mm
index 47bef3ca4..a0df0ff84 100644
--- a/tests/cefclient/browser/text_input_client_osr_mac.mm
+++ b/tests/cefclient/browser/text_input_client_osr_mac.mm
@@ -89,8 +89,9 @@ extern NSString* NSTextInputReplacementRangeAttributeName;
 }
 
 - (NSRange)selectedRange {
-  if (selectedRange_.location == NSNotFound || selectedRange_.length == 0)
+  if (selectedRange_.location == NSNotFound || selectedRange_.length == 0) {
     return NSMakeRange(NSNotFound, 0);
+  }
   return selectedRange_;
 }
 
@@ -177,10 +178,11 @@ extern NSString* NSTextInputReplacementRangeAttributeName;
 
   // If we are handling a key down event then ImeFinishComposingText() will be
   // called from the keyEvent: method.
-  if (!handlingKeyDown_)
+  if (!handlingKeyDown_) {
     browser_->GetHost()->ImeFinishComposingText(false);
-  else
+  } else {
     unmarkTextCalled_ = YES;
+  }
 }
 
 - (NSAttributedString*)attributedSubstringForProposedRange:(NSRange)range
@@ -198,20 +200,23 @@ extern NSString* NSTextInputReplacementRangeAttributeName;
   NSUInteger location = theRange.location;
 
   // If location is not specified fall back to the composition range start.
-  if (location == NSNotFound)
+  if (location == NSNotFound) {
     location = markedRange_.location;
+  }
 
   // Offset location by the composition range start if required.
-  if (location >= markedRange_.location)
+  if (location >= markedRange_.location) {
     location -= markedRange_.location;
+  }
 
   if (location < composition_bounds_.size()) {
     const CefRect& rc = composition_bounds_[location];
     rect = NSMakeRect(rc.x, rc.y, rc.width, rc.height);
   }
 
-  if (actualRange)
+  if (actualRange) {
     *actualRange = NSMakeRange(location, theRange.length);
+  }
 
   return rect;
 }
@@ -236,10 +241,11 @@ extern NSString* NSTextInputReplacementRangeAttributeName;
   // Convert into screen coordinates for return.
   rect = [self screenRectFromViewRect:rect];
 
-  if (rect.origin.y >= rect.size.height)
+  if (rect.origin.y >= rect.size.height) {
     rect.origin.y -= rect.size.height;
-  else
+  } else {
     rect.origin.y = 0;
+  }
 
   return rect;
 }
@@ -284,8 +290,9 @@ extern NSString* NSTextInputReplacementRangeAttributeName;
     // Don't send a CHAR event for non-char keys like arrows, function keys and
     // clear.
     if (keyEvent.modifiers & (EVENTFLAG_IS_KEY_PAD)) {
-      if (keyEvent.native_key_code == 71)
+      if (keyEvent.native_key_code == 71) {
         return;
+      }
     }
 
     keyEvent.type = KEYEVENT_CHAR;
@@ -313,10 +320,11 @@ extern NSString* NSTextInputReplacementRangeAttributeName;
   } else if (oldHasMarkedText_ && !hasMarkedText_ && !textInserted) {
     // There was no marked text or inserted text. Complete or cancel the
     // composition.
-    if (unmarkTextCalled_)
+    if (unmarkTextCalled_) {
       browser_->GetHost()->ImeFinishComposingText(false);
-    else
+    } else {
       browser_->GetHost()->ImeCancelComposition();
+    }
   }
 
   setMarkedTextReplacementRange_ = CefRange(UINT32_MAX, UINT32_MAX);
@@ -330,8 +338,9 @@ extern NSString* NSTextInputReplacementRangeAttributeName;
 }
 
 - (void)cancelComposition {
-  if (!hasMarkedText_)
+  if (!hasMarkedText_) {
     return;
+  }
 
 // Cancel the ongoing composition. [NSInputManager markedTextAbandoned:]
 // doesn't call any NSTextInput functions, such as setMarkedText or
diff --git a/tests/cefclient/browser/urlrequest_test.cc b/tests/cefclient/browser/urlrequest_test.cc
index ea53197ca..a84976bb7 100644
--- a/tests/cefclient/browser/urlrequest_test.cc
+++ b/tests/cefclient/browser/urlrequest_test.cc
@@ -37,8 +37,9 @@ class RequestClient : public CefURLRequestClient {
 
   void Detach() {
     CEF_REQUIRE_UI_THREAD();
-    if (!callback_.is_null())
+    if (!callback_.is_null()) {
       callback_.Reset();
+    }
   }
 
   void OnRequestComplete(CefRefPtr<CefURLRequest> request) override {
@@ -98,8 +99,9 @@ class Handler : public CefMessageRouterBrowserSide::Handler {
 
     // Only handle messages from the test URL.
     const std::string& url = frame->GetURL();
-    if (!test_runner::IsTestURL(url, kTestUrlPath))
+    if (!test_runner::IsTestURL(url, kTestUrlPath)) {
       return false;
+    }
 
     const std::string& message_name = request;
     if (message_name.find(kTestMessageName) == 0) {
@@ -160,10 +162,11 @@ class Handler : public CefMessageRouterBrowserSide::Handler {
                          const std::string& download_data) {
     CEF_REQUIRE_UI_THREAD();
 
-    if (error_code == ERR_NONE)
+    if (error_code == ERR_NONE) {
       callback_->Success(download_data);
-    else
+    } else {
       callback_->Failure(error_code, test_runner::GetErrorString(error_code));
+    }
 
     callback_ = nullptr;
     urlrequest_ = nullptr;
diff --git a/tests/cefclient/browser/views_menu_bar.cc b/tests/cefclient/browser/views_menu_bar.cc
index a92d05b05..f8746a2b1 100644
--- a/tests/cefclient/browser/views_menu_bar.cc
+++ b/tests/cefclient/browser/views_menu_bar.cc
@@ -33,8 +33,9 @@ char16 GetMnemonic(const std::u16string& title) {
   do {
     index = title.find('&', index);
     if (index != std::u16string::npos) {
-      if (index + 1 != title.size() && title[index + 1] != '&')
+      if (index + 1 != title.size() && title[index + 1] != '&') {
         return ToLower(title[index + 1]);
+      }
       index++;
     }
   } while (index != std::u16string::npos);
@@ -67,8 +68,9 @@ CefRefPtr<CefMenuModel> ViewsMenuBar::CreateMenuModel(const CefString& label,
 
   // Assign the new menu ID.
   const int new_menu_id = id_next_++;
-  if (menu_id)
+  if (menu_id) {
     *menu_id = new_menu_id;
+  }
 
   // Create the new MenuModel.
   CefRefPtr<CefMenuModel> model = CefMenuModel::CreateMenuModel(this);
@@ -91,24 +93,28 @@ CefRefPtr<CefMenuModel> ViewsMenuBar::CreateMenuModel(const CefString& label,
 
   // Extract the mnemonic that triggers the menu, if any.
   char16 mnemonic = GetMnemonic(label);
-  if (mnemonic != 0)
+  if (mnemonic != 0) {
     mnemonics_.insert(std::make_pair(mnemonic, new_menu_id));
+  }
 
   return model;
 }
 
 CefRefPtr<CefMenuModel> ViewsMenuBar::GetMenuModel(int menu_id) const {
-  if (HasMenuId(menu_id))
+  if (HasMenuId(menu_id)) {
     return models_[menu_id - id_start_];
+  }
   return nullptr;
 }
 
 void ViewsMenuBar::SetMenuFocusable(bool focusable) {
-  if (!panel_)
+  if (!panel_) {
     return;
+  }
 
-  for (int id = id_start_; id < id_next_; ++id)
+  for (int id = id_start_; id < id_next_; ++id) {
     panel_->GetViewForID(id)->SetFocusable(focusable);
+  }
 
   if (focusable) {
     // Give focus to the first MenuButton.
@@ -117,20 +123,24 @@ void ViewsMenuBar::SetMenuFocusable(bool focusable) {
 }
 
 bool ViewsMenuBar::OnKeyEvent(const CefKeyEvent& event) {
-  if (!panel_)
+  if (!panel_) {
     return false;
+  }
 
-  if (event.type != KEYEVENT_RAWKEYDOWN)
+  if (event.type != KEYEVENT_RAWKEYDOWN) {
     return false;
+  }
 
   // Do not check mnemonics if the Alt or Ctrl modifiers are pressed. For
   // example Ctrl+<T> is an accelerator, but <T> only is a mnemonic.
-  if (event.modifiers & (EVENTFLAG_ALT_DOWN | EVENTFLAG_CONTROL_DOWN))
+  if (event.modifiers & (EVENTFLAG_ALT_DOWN | EVENTFLAG_CONTROL_DOWN)) {
     return false;
+  }
 
   MnemonicMap::const_iterator it = mnemonics_.find(ToLower(event.character));
-  if (it == mnemonics_.end())
+  if (it == mnemonics_.end()) {
     return false;
+  }
 
   // Set status indicating that we navigated using the keyboard.
   last_nav_with_keyboard_ = true;
@@ -189,30 +199,34 @@ void ViewsMenuBar::MouseOutsideMenu(CefRefPtr<CefMenuModel> menu_model,
 
   // Convert the point from screen to window coordinates.
   CefPoint window_point = screen_point;
-  if (!window->ConvertPointFromScreen(window_point))
+  if (!window->ConvertPointFromScreen(window_point)) {
     return;
+  }
 
   CefRect panel_bounds = panel_->GetBounds();
 
   if (last_nav_with_keyboard_) {
     // The user navigated last using the keyboard. Don't change menus using
     // mouse movements until the mouse exits and re-enters the Panel.
-    if (panel_bounds.Contains(window_point))
+    if (panel_bounds.Contains(window_point)) {
       return;
+    }
     last_nav_with_keyboard_ = false;
   }
 
   // Check that the point is inside the Panel.
-  if (!panel_bounds.Contains(window_point))
+  if (!panel_bounds.Contains(window_point)) {
     return;
+  }
 
   const int active_menu_id = GetActiveMenuId();
 
   // Determine which MenuButton is under the specified point.
   for (int id = id_start_; id < id_next_; ++id) {
     // Skip the currently active MenuButton.
-    if (id == active_menu_id)
+    if (id == active_menu_id) {
       continue;
+    }
 
     CefRefPtr<CefView> button = panel_->GetViewForID(id);
     CefRect button_bounds = button->GetBounds();
@@ -241,13 +255,15 @@ void ViewsMenuBar::UnhandledCloseSubmenu(CefRefPtr<CefMenuModel> menu_model,
 
 void ViewsMenuBar::MenuClosed(CefRefPtr<CefMenuModel> menu_model) {
   // Reset |last_nav_with_keyboard_| status whenever the main menu closes.
-  if (!menu_model->IsSubMenu() && last_nav_with_keyboard_)
+  if (!menu_model->IsSubMenu() && last_nav_with_keyboard_) {
     last_nav_with_keyboard_ = false;
+  }
 }
 
 void ViewsMenuBar::EnsureMenuPanel() {
-  if (panel_)
+  if (panel_) {
     return;
+  }
 
   panel_ = CefPanel::CreatePanel(nullptr);
   views_style::ApplyTo(panel_);
@@ -263,8 +279,9 @@ int ViewsMenuBar::GetActiveMenuId() {
 
   for (int id = id_start_; id < id_next_; ++id) {
     CefRefPtr<CefButton> button = panel_->GetViewForID(id)->AsButton();
-    if (button->GetState() == CEF_BUTTON_STATE_PRESSED)
+    if (button->GetState() == CEF_BUTTON_STATE_PRESSED) {
       return id;
+    }
   }
 
   return -1;
@@ -279,8 +296,9 @@ void ViewsMenuBar::TriggerNextMenu(int offset) {
 
   // Compute the modulus to avoid negative values.
   int next_menu_index = (active_menu_index + offset) % menu_count;
-  if (next_menu_index < 0)
+  if (next_menu_index < 0) {
     next_menu_index += menu_count;
+  }
 
   // Cancel the existing menu. MenuClosed may be called.
   panel_->GetWindow()->CancelMenu();
@@ -295,8 +313,9 @@ void ViewsMenuBar::TriggerNextMenu(int offset) {
 void ViewsMenuBar::TriggerMenuButton(CefRefPtr<CefView> button) {
   CefRefPtr<CefMenuButton> menu_button =
       button->AsButton()->AsLabelButton()->AsMenuButton();
-  if (menu_button->IsFocusable())
+  if (menu_button->IsFocusable()) {
     menu_button->RequestFocus();
+  }
   menu_button->TriggerMenu();
 }
 
diff --git a/tests/cefclient/browser/views_overlay_controls.cc b/tests/cefclient/browser/views_overlay_controls.cc
index 0991fb03b..38ebba0bf 100644
--- a/tests/cefclient/browser/views_overlay_controls.cc
+++ b/tests/cefclient/browser/views_overlay_controls.cc
@@ -147,10 +147,11 @@ void ViewsOverlayControls::OnButtonPressed(CefRefPtr<CefButton> button) {
       window_->Minimize();
       break;
     case ViewsOverlayControls::Command::kMaximize:
-      if (window_->IsMaximized())
+      if (window_->IsMaximized()) {
         window_->Restore();
-      else
+      } else {
         window_->Maximize();
+      }
       break;
     case ViewsOverlayControls::Command::kClose:
       window_->Close();
@@ -163,8 +164,9 @@ void ViewsOverlayControls::OnButtonPressed(CefRefPtr<CefButton> button) {
   button->SetInkDropEnabled(false);
   button->SetInkDropEnabled(true);
 
-  if (command == Command::kMaximize)
+  if (command == Command::kMaximize) {
     MaybeUpdateMaximizeButton();
+  }
 }
 
 CefRefPtr<CefLabelButton> ViewsOverlayControls::CreateButton(Command command) {
@@ -178,8 +180,9 @@ CefRefPtr<CefLabelButton> ViewsOverlayControls::CreateButton(Command command) {
 }
 
 void ViewsOverlayControls::MaybeUpdateMaximizeButton() {
-  if (window_->IsMaximized() == window_maximized_)
+  if (window_->IsMaximized() == window_maximized_) {
     return;
+  }
   window_maximized_ = !window_maximized_;
 
   auto max_button = panel_->GetChildViewAt(1);
diff --git a/tests/cefclient/browser/views_style.cc b/tests/cefclient/browser/views_style.cc
index 030e77457..4021ebd96 100644
--- a/tests/cefclient/browser/views_style.cc
+++ b/tests/cefclient/browser/views_style.cc
@@ -22,8 +22,9 @@ int GetShade(int component) {
 
 void MaybeInitialize() {
   static bool initialized = false;
-  if (initialized)
+  if (initialized) {
     return;
+  }
 
   g_background_color = MainContext::Get()->GetBackgroundColor();
   if (g_background_color != 0) {
@@ -50,22 +51,25 @@ bool IsSet() {
 }
 
 void ApplyBackgroundTo(CefRefPtr<CefView> view) {
-  if (!IsSet())
+  if (!IsSet()) {
     return;
+  }
 
   view->SetBackgroundColor(g_background_color);
 }
 
 void ApplyTo(CefRefPtr<CefPanel> panel) {
-  if (!IsSet())
+  if (!IsSet()) {
     return;
+  }
 
   panel->SetBackgroundColor(g_background_color);
 }
 
 void ApplyTo(CefRefPtr<CefLabelButton> label_button) {
-  if (!IsSet())
+  if (!IsSet()) {
     return;
+  }
 
   // All text except disabled gets the same color.
   label_button->SetEnabledTextColors(g_text_color);
@@ -76,16 +80,18 @@ void ApplyTo(CefRefPtr<CefLabelButton> label_button) {
 }
 
 void ApplyTo(CefRefPtr<CefTextfield> textfield) {
-  if (!IsSet())
+  if (!IsSet()) {
     return;
+  }
 
   textfield->SetBackgroundColor(g_background_color);
   textfield->SetTextColor(g_text_color);
 }
 
 void ApplyTo(CefRefPtr<CefMenuModel> menu_model) {
-  if (!IsSet())
+  if (!IsSet()) {
     return;
+  }
 
   // All text except non-hovered accelerator gets the same color.
   menu_model->SetColorAt(-1, CEF_MENU_COLOR_TEXT, g_text_color);
@@ -101,8 +107,9 @@ void ApplyTo(CefRefPtr<CefMenuModel> menu_model) {
 
   // Recursively color sub-menus.
   for (size_t i = 0; i < menu_model->GetCount(); ++i) {
-    if (menu_model->GetTypeAt(i) == MENUITEMTYPE_SUBMENU)
+    if (menu_model->GetTypeAt(i) == MENUITEMTYPE_SUBMENU) {
       ApplyTo(menu_model->GetSubMenuAt(i));
+    }
   }
 }
 
diff --git a/tests/cefclient/browser/views_window.cc b/tests/cefclient/browser/views_window.cc
index 8b36a6cfc..59092d7b6 100644
--- a/tests/cefclient/browser/views_window.cc
+++ b/tests/cefclient/browser/views_window.cc
@@ -63,10 +63,12 @@ void MakeButtonsSameSize(const LabelButtons& buttons) {
   // Determine the largest button size.
   for (size_t i = 0U; i < buttons.size(); ++i) {
     const CefSize& button_size = buttons[i]->GetPreferredSize();
-    if (size.width < button_size.width)
+    if (size.width < button_size.width) {
       size.width = button_size.width;
-    if (size.height < button_size.height)
+    }
+    if (size.height < button_size.height) {
       size.height = button_size.height;
+    }
   }
 
   for (size_t i = 0U; i < buttons.size(); ++i) {
@@ -134,8 +136,9 @@ CefRefPtr<ViewsWindow> ViewsWindow::Create(
 
 void ViewsWindow::Show() {
   CEF_REQUIRE_UI_THREAD();
-  if (window_)
+  if (window_) {
     window_->Show();
+  }
   if (browser_view_ && !window_->IsMinimized()) {
     // Give keyboard focus to the BrowserView.
     browser_view_->RequestFocus();
@@ -144,45 +147,52 @@ void ViewsWindow::Show() {
 
 void ViewsWindow::Hide() {
   CEF_REQUIRE_UI_THREAD();
-  if (window_)
+  if (window_) {
     window_->Hide();
+  }
 }
 
 void ViewsWindow::Minimize() {
   CEF_REQUIRE_UI_THREAD();
-  if (window_)
+  if (window_) {
     window_->Minimize();
+  }
 }
 
 void ViewsWindow::Maximize() {
   CEF_REQUIRE_UI_THREAD();
-  if (window_)
+  if (window_) {
     window_->Maximize();
+  }
 }
 
 void ViewsWindow::SetBounds(const CefRect& bounds) {
   CEF_REQUIRE_UI_THREAD();
-  if (window_)
+  if (window_) {
     window_->SetBounds(bounds);
+  }
 }
 
 void ViewsWindow::SetBrowserSize(const CefSize& size,
                                  bool has_position,
                                  const CefPoint& position) {
   CEF_REQUIRE_UI_THREAD();
-  if (browser_view_)
+  if (browser_view_) {
     browser_view_->SetSize(size);
+  }
   if (window_) {
     window_->SizeToPreferredSize();
-    if (has_position)
+    if (has_position) {
       window_->SetPosition(position);
+    }
   }
 }
 
 void ViewsWindow::Close(bool force) {
   CEF_REQUIRE_UI_THREAD();
-  if (!browser_view_)
+  if (!browser_view_) {
     return;
+  }
 
   CefRefPtr<CefBrowser> browser = browser_view_->GetBrowser();
   if (browser) {
@@ -194,18 +204,21 @@ void ViewsWindow::Close(bool force) {
 
 void ViewsWindow::SetAddress(const std::string& url) {
   CEF_REQUIRE_UI_THREAD();
-  if (!window_)
+  if (!window_) {
     return;
+  }
 
   // |location_bar_| may instead be a Chrome toolbar.
-  if (location_bar_ && location_bar_->AsTextfield())
+  if (location_bar_ && location_bar_->AsTextfield()) {
     location_bar_->AsTextfield()->SetText(url);
+  }
 }
 
 void ViewsWindow::SetTitle(const std::string& title) {
   CEF_REQUIRE_UI_THREAD();
-  if (window_)
+  if (window_) {
     window_->SetTitle(title);
+  }
 }
 
 void ViewsWindow::SetFavicon(CefRefPtr<CefImage> image) {
@@ -214,16 +227,18 @@ void ViewsWindow::SetFavicon(CefRefPtr<CefImage> image) {
   // Window icons should be 16 DIP in size.
   DCHECK_EQ(std::max(image->GetWidth(), image->GetHeight()), 16U);
 
-  if (window_)
+  if (window_) {
     window_->SetWindowIcon(image);
+  }
 }
 
 void ViewsWindow::SetFullscreen(bool fullscreen) {
   CEF_REQUIRE_UI_THREAD();
   if (window_) {
     // Hide the top controls while in full-screen mode.
-    if (with_controls_)
+    if (with_controls_) {
       ShowTopControls(!fullscreen);
+    }
 
     window_->SetFullscreen(fullscreen);
   }
@@ -240,8 +255,9 @@ void ViewsWindow::SetLoadingState(bool isLoading,
                                   bool canGoBack,
                                   bool canGoForward) {
   CEF_REQUIRE_UI_THREAD();
-  if (!window_ || chrome_toolbar_type_ == CEF_CTT_NORMAL)
+  if (!window_ || chrome_toolbar_type_ == CEF_CTT_NORMAL) {
     return;
+  }
 
   if (with_controls_) {
     EnableView(ID_BACK_BUTTON, canGoBack);
@@ -258,8 +274,9 @@ void ViewsWindow::SetDraggableRegions(
     const std::vector<CefDraggableRegion>& regions) {
   CEF_REQUIRE_UI_THREAD();
 
-  if (!window_ || !browser_view_)
+  if (!window_ || !browser_view_) {
     return;
+  }
 
   std::vector<CefDraggableRegion> window_regions;
 
@@ -285,8 +302,9 @@ void ViewsWindow::SetDraggableRegions(
 void ViewsWindow::TakeFocus(bool next) {
   CEF_REQUIRE_UI_THREAD();
 
-  if (!window_)
+  if (!window_) {
     return;
+  }
 
   if (chrome_toolbar_type_ == CEF_CTT_NORMAL) {
     top_toolbar_->RequestFocus();
@@ -340,16 +358,18 @@ bool ViewsWindow::GetWindowRestorePreferences(
     cef_show_state_t& show_state,
     std::optional<CefRect>& dip_bounds) {
   CEF_REQUIRE_UI_THREAD();
-  if (!window_)
+  if (!window_) {
     return false;
+  }
 
   show_state = CEF_SHOW_STATE_NORMAL;
-  if (window_->IsMinimized())
+  if (window_->IsMinimized()) {
     show_state = CEF_SHOW_STATE_MINIMIZED;
-  else if (window_->IsMaximized())
+  } else if (window_->IsMaximized()) {
     show_state = CEF_SHOW_STATE_MAXIMIZED;
-  else if (window_->IsFullscreen())
+  } else if (window_->IsFullscreen()) {
     show_state = CEF_SHOW_STATE_FULLSCREEN;
+  }
 
   if (show_state == CEF_SHOW_STATE_NORMAL) {
     // Use the current visible bounds.
@@ -375,8 +395,9 @@ CefRefPtr<CefBrowserViewDelegate> ViewsWindow::GetDelegateForPopupBrowserView(
   Delegate* popup_delegate = delegate_->GetDelegateForPopup(client);
 
   // May be nullptr when using the default popup behavior.
-  if (!popup_delegate)
+  if (!popup_delegate) {
     return nullptr;
+  }
 
   // Should not be the same RootWindowViews that owns |this|.
   DCHECK(popup_delegate != delegate_);
@@ -397,8 +418,9 @@ bool ViewsWindow::OnPopupBrowserViewCreated(
           popup_browser_view->GetDelegate().get()));
 
   // May be nullptr when using the default popup behavior.
-  if (!popup_window)
+  if (!popup_window) {
     return false;
+  }
 
   // Should not be the same ViewsWindow as |this|.
   DCHECK(popup_window != this);
@@ -422,12 +444,14 @@ void ViewsWindow::OnButtonPressed(CefRefPtr<CefButton> button) {
   CEF_REQUIRE_UI_THREAD();
   DCHECK(with_controls_);
 
-  if (!browser_view_)
+  if (!browser_view_) {
     return;
+  }
 
   CefRefPtr<CefBrowser> browser = browser_view_->GetBrowser();
-  if (!browser)
+  if (!browser) {
     return;
+  }
 
   switch (button->GetID()) {
     case ID_BACK_BUTTON:
@@ -519,8 +543,9 @@ bool ViewsWindow::OnKeyEvent(CefRefPtr<CefTextfield> textfield,
     CefRefPtr<CefBrowser> browser = browser_view_->GetBrowser();
     if (browser) {
       const CefString& url = textfield->GetText();
-      if (!url.empty())
+      if (!url.empty()) {
         browser->GetMainFrame()->LoadURL(url);
+      }
     }
 
     // We handled the event.
@@ -635,8 +660,9 @@ bool ViewsWindow::CanClose(CefRefPtr<CefWindow> window) {
 
   // Allow the window to close if the browser says it's OK.
   CefRefPtr<CefBrowser> browser = browser_view_->GetBrowser();
-  if (browser)
+  if (browser) {
     return browser->GetHost()->TryCloseBrowser();
+  }
   return true;
 }
 
@@ -696,8 +722,9 @@ bool ViewsWindow::OnKeyEvent(CefRefPtr<CefWindow> window,
                              const CefKeyEvent& event) {
   CEF_REQUIRE_UI_THREAD();
 
-  if (!window_)
+  if (!window_) {
     return false;
+  }
 
   if (delegate_->WithExtension() && event.type == KEYEVENT_RAWKEYDOWN &&
       event.windows_key_code == VK_ESCAPE) {
@@ -706,8 +733,9 @@ bool ViewsWindow::OnKeyEvent(CefRefPtr<CefWindow> window,
     return true;
   }
 
-  if (!with_controls_)
+  if (!with_controls_) {
     return false;
+  }
 
   if (event.type == KEYEVENT_RAWKEYDOWN && event.windows_key_code == VK_MENU) {
     // ALT key is pressed.
@@ -725,8 +753,9 @@ bool ViewsWindow::OnKeyEvent(CefRefPtr<CefWindow> window,
     return true;
   }
 
-  if (menu_has_focus_ && top_menu_bar_)
+  if (menu_has_focus_ && top_menu_bar_) {
     return top_menu_bar_->OnKeyEvent(event);
+  }
 
   return false;
 }
@@ -734,8 +763,9 @@ bool ViewsWindow::OnKeyEvent(CefRefPtr<CefWindow> window,
 CefSize ViewsWindow::GetMinimumSize(CefRefPtr<CefView> view) {
   CEF_REQUIRE_UI_THREAD();
 
-  if (view->GetID() == ID_WINDOW)
+  if (view->GetID() == ID_WINDOW) {
     return minimum_window_size_;
+  }
 
   return CefSize();
 }
@@ -754,8 +784,9 @@ void ViewsWindow::OnFocus(CefRefPtr<CefView> view) {
   // When focus leaves the menu buttons make them unfocusable.
   if (menu_has_focus_) {
     if (top_menu_bar_) {
-      if (!top_menu_bar_->HasMenuId(view_id))
+      if (!top_menu_bar_->HasMenuId(view_id)) {
         SetMenuFocusable(false);
+      }
     } else if (view_id != ID_MENU_BUTTON) {
       SetMenuFocusable(false);
     }
@@ -774,8 +805,9 @@ void ViewsWindow::OnBlur(CefRefPtr<CefView> view) {
 
 void ViewsWindow::OnWindowChanged(CefRefPtr<CefView> view, bool added) {
   const int view_id = view->GetID();
-  if (view_id != ID_BROWSER_VIEW)
+  if (view_id != ID_BROWSER_VIEW) {
     return;
+  }
 
   if (added) {
     if (with_controls_) {
@@ -802,8 +834,9 @@ void ViewsWindow::OnWindowChanged(CefRefPtr<CefView> view, bool added) {
 void ViewsWindow::OnLayoutChanged(CefRefPtr<CefView> view,
                                   const CefRect& new_bounds) {
   const int view_id = view->GetID();
-  if (view_id != ID_BROWSER_VIEW)
+  if (view_id != ID_BROWSER_VIEW) {
     return;
+  }
 
   if (overlay_controls_) {
     overlay_controls_->UpdateControls();
@@ -823,8 +856,9 @@ ViewsWindow::ViewsWindow(Delegate* delegate,
       menu_has_focus_(false),
       last_focused_view_(false) {
   DCHECK(delegate_);
-  if (browser_view)
+  if (browser_view) {
     SetBrowserView(browser_view);
+  }
 
   CefRefPtr<CefCommandLine> command_line =
       CefCommandLine::GetGlobalCommandLine();
@@ -959,8 +993,9 @@ void ViewsWindow::AddControls() {
   // the CefWindow. This is a requirement to use Chrome toolbars.
 
   CefRefPtr<CefPanel> top_menu_panel;
-  if (top_menu_bar_)
+  if (top_menu_bar_) {
     top_menu_panel = top_menu_bar_->GetMenuPanel();
+  }
 
   LabelButtons browse_buttons;
 
@@ -990,8 +1025,9 @@ void ViewsWindow::AddControls() {
         top_panel->SetToBoxLayout(top_panel_layout_settings);
 
     // Add the buttons and URL textfield to |top_panel|.
-    for (size_t i = 0U; i < browse_buttons.size(); ++i)
+    for (size_t i = 0U; i < browse_buttons.size(); ++i) {
       top_panel->AddChildView(browse_buttons[i]);
+    }
     top_panel->AddChildView(location_bar_);
 
     UpdateExtensionControls();
@@ -1009,8 +1045,9 @@ void ViewsWindow::AddControls() {
 
   // Add the top panel and browser view to |window|.
   int top_index = 0;
-  if (top_menu_panel)
+  if (top_menu_panel) {
     window_->AddChildViewAt(top_menu_panel, top_index++);
+  }
   window_->AddChildViewAt(top_toolbar_, top_index);
 
   // Lay out |window| so we can get the default button sizes.
@@ -1031,8 +1068,9 @@ void ViewsWindow::AddControls() {
 
   // Minimum window height is the hight of the top toolbar plus some extra.
   int min_height = top_toolbar_->GetBounds().height + 100;
-  if (top_menu_panel)
+  if (top_menu_panel) {
     min_height += top_menu_panel->GetBounds().height;
+  }
 
   minimum_window_size_ = CefSize(min_width, min_height);
 }
@@ -1047,8 +1085,9 @@ void ViewsWindow::AddAccelerators() {
 }
 
 void ViewsWindow::SetMenuFocusable(bool focusable) {
-  if (!window_ || !with_controls_)
+  if (!window_ || !with_controls_) {
     return;
+  }
 
   if (top_menu_bar_) {
     top_menu_bar_->SetMenuFocusable(focusable);
@@ -1065,19 +1104,22 @@ void ViewsWindow::SetMenuFocusable(bool focusable) {
 }
 
 void ViewsWindow::EnableView(int id, bool enable) {
-  if (!window_)
+  if (!window_) {
     return;
+  }
   // Special handling for |location_bar_| which may be an overlay (e.g. not a
   // child of this view).
   CefRefPtr<CefView> view =
       id == ID_URL_TEXTFIELD ? location_bar_ : window_->GetViewForID(id);
-  if (view)
+  if (view) {
     view->SetEnabled(enable);
+  }
 }
 
 void ViewsWindow::ShowTopControls(bool show) {
-  if (!window_ || !with_controls_)
+  if (!window_ || !with_controls_) {
     return;
+  }
 
   // Change the visibility of the top toolbar.
   if (top_toolbar_->IsVisible() != show) {
@@ -1089,8 +1131,9 @@ void ViewsWindow::ShowTopControls(bool show) {
 void ViewsWindow::UpdateExtensionControls() {
   CEF_REQUIRE_UI_THREAD();
 
-  if (!window_ || !with_controls_)
+  if (!window_ || !with_controls_) {
     return;
+  }
 
   if (!extensions_panel_) {
     extensions_panel_ = CefPanel::CreatePanel(nullptr);
@@ -1125,8 +1168,9 @@ void ViewsWindow::UpdateExtensionControls() {
   }
 
   CefRefPtr<CefView> parent_view = extensions_panel_->GetParentView();
-  if (parent_view)
+  if (parent_view) {
     parent_view->InvalidateLayout();
+  }
 }
 
 void ViewsWindow::OnExtensionIconsLoaded(const ExtensionSet& extensions,
@@ -1146,8 +1190,9 @@ void ViewsWindow::OnExtensionIconsLoaded(const ExtensionSet& extensions,
   ImageCache::ImageSet::const_iterator it2 = images.begin();
   for (; it1 != extensions.end() && it2 != images.end(); ++it1, ++it2) {
     CefRefPtr<CefImage> icon = *it2;
-    if (!icon)
+    if (!icon) {
       icon = delegate_->GetImageCache()->GetCachedImage(kDefaultExtensionIcon);
+    }
     extensions_.push_back(ExtensionInfo(*it1, icon));
   }
 
diff --git a/tests/cefclient/browser/window_test.cc b/tests/cefclient/browser/window_test.cc
index 8211e1eba..1baf28d64 100644
--- a/tests/cefclient/browser/window_test.cc
+++ b/tests/cefclient/browser/window_test.cc
@@ -41,8 +41,9 @@ const char kMessageRestoreName[] = "WindowTest.Restore";
 // Create the appropriate platform test runner object.
 std::unique_ptr<WindowTestRunner> CreateWindowTestRunner() {
 #if defined(OS_WIN) || defined(OS_LINUX)
-  if (MainContext::Get()->UseViews())
+  if (MainContext::Get()->UseViews()) {
     return std::make_unique<WindowTestRunnerViews>();
+  }
 #endif
 
 #if defined(OS_WIN)
@@ -70,8 +71,9 @@ class Handler : public CefMessageRouterBrowserSide::Handler {
                        CefRefPtr<Callback> callback) override {
     // Only handle messages from the test URL.
     const std::string& url = frame->GetURL();
-    if (!test_runner::IsTestURL(url, kTestUrlPath))
+    if (!test_runner::IsTestURL(url, kTestUrlPath)) {
       return false;
+    }
 
     const std::string& message_name = request;
     if (message_name.find(kMessagePositionName) == 0) {
@@ -83,8 +85,9 @@ class Handler : public CefMessageRouterBrowserSide::Handler {
       int i;
       while (ss >> i) {
         vec.push_back(i);
-        if (ss.peek() == ',')
+        if (ss.peek() == ',') {
           ss.ignore();
+        }
       }
 
       if (vec.size() == 4) {
diff --git a/tests/cefclient/browser/window_test_runner.cc b/tests/cefclient/browser/window_test_runner.cc
index 05f1ac59b..b410812f4 100644
--- a/tests/cefclient/browser/window_test_runner.cc
+++ b/tests/cefclient/browser/window_test_runner.cc
@@ -12,22 +12,28 @@ void WindowTestRunner::ModifyBounds(const CefRect& display, CefRect& window) {
   window.x += display.x;
   window.y += display.y;
 
-  if (window.x < display.x)
+  if (window.x < display.x) {
     window.x = display.x;
-  if (window.y < display.y)
+  }
+  if (window.y < display.y) {
     window.y = display.y;
-  if (window.width < 100)
+  }
+  if (window.width < 100) {
     window.width = 100;
-  else if (window.width >= display.width)
+  } else if (window.width >= display.width) {
     window.width = display.width;
-  if (window.height < 100)
+  }
+  if (window.height < 100) {
     window.height = 100;
-  else if (window.height >= display.height)
+  } else if (window.height >= display.height) {
     window.height = display.height;
-  if (window.x + window.width >= display.x + display.width)
+  }
+  if (window.x + window.width >= display.x + display.width) {
     window.x = display.x + display.width - window.width;
-  if (window.y + window.height >= display.y + display.height)
+  }
+  if (window.y + window.height >= display.y + display.height) {
     window.y = display.y + display.height - window.height;
+  }
 }
 
 }  // namespace window_test
diff --git a/tests/cefclient/browser/window_test_runner_gtk.cc b/tests/cefclient/browser/window_test_runner_gtk.cc
index bce9407c2..a5093f165 100644
--- a/tests/cefclient/browser/window_test_runner_gtk.cc
+++ b/tests/cefclient/browser/window_test_runner_gtk.cc
@@ -21,8 +21,9 @@ GtkWindow* GetWindow(CefRefPtr<CefBrowser> browser) {
       RootWindow::GetForBrowser(browser->GetIdentifier());
   if (root_window) {
     GtkWindow* window = GTK_WINDOW(root_window->GetWindowHandle());
-    if (!window)
+    if (!window) {
       LOG(ERROR) << "No GtkWindow for browser";
+    }
     return window;
   }
   return nullptr;
@@ -43,15 +44,17 @@ void SetPosImpl(CefRefPtr<CefBrowser> browser,
   ScopedGdkThreadsEnter scoped_gdk_threads;
 
   GtkWindow* window = GetWindow(browser);
-  if (!window)
+  if (!window) {
     return;
+  }
   GdkWindow* gdk_window = gtk_widget_get_window(GTK_WIDGET(window));
 
   // Make sure the window isn't minimized or maximized.
-  if (IsMaximized(window))
+  if (IsMaximized(window)) {
     gtk_window_unmaximize(window);
-  else
+  } else {
     gtk_window_present(window);
+  }
 
   // Retrieve information about the display that contains the window.
   GdkScreen* screen = gdk_screen_get_default();
@@ -73,12 +76,14 @@ void MinimizeImpl(CefRefPtr<CefBrowser> browser) {
   ScopedGdkThreadsEnter scoped_gdk_threads;
 
   GtkWindow* window = GetWindow(browser);
-  if (!window)
+  if (!window) {
     return;
+  }
 
   // Unmaximize the window before minimizing so restore behaves correctly.
-  if (IsMaximized(window))
+  if (IsMaximized(window)) {
     gtk_window_unmaximize(window);
+  }
 
   gtk_window_iconify(window);
 }
@@ -88,8 +93,9 @@ void MaximizeImpl(CefRefPtr<CefBrowser> browser) {
   ScopedGdkThreadsEnter scoped_gdk_threads;
 
   GtkWindow* window = GetWindow(browser);
-  if (!window)
+  if (!window) {
     return;
+  }
   gtk_window_maximize(window);
 }
 
@@ -98,12 +104,14 @@ void RestoreImpl(CefRefPtr<CefBrowser> browser) {
   ScopedGdkThreadsEnter scoped_gdk_threads;
 
   GtkWindow* window = GetWindow(browser);
-  if (!window)
+  if (!window) {
     return;
-  if (IsMaximized(window))
+  }
+  if (IsMaximized(window)) {
     gtk_window_unmaximize(window);
-  else
+  } else {
     gtk_window_present(window);
+  }
 }
 
 }  // namespace
diff --git a/tests/cefclient/browser/window_test_runner_mac.mm b/tests/cefclient/browser/window_test_runner_mac.mm
index 2a04d09e1..1f1814461 100644
--- a/tests/cefclient/browser/window_test_runner_mac.mm
+++ b/tests/cefclient/browser/window_test_runner_mac.mm
@@ -35,15 +35,17 @@ void WindowTestRunnerMac::SetPos(CefRefPtr<CefBrowser> browser,
   NSWindow* window = GetWindow(browser);
 
   // Make sure the window isn't minimized or maximized.
-  if ([window isMiniaturized])
+  if ([window isMiniaturized]) {
     [window deminiaturize:nil];
-  else if ([window isZoomed])
+  } else if ([window isZoomed]) {
     [window performZoom:nil];
+  }
 
   // Retrieve information for the display that contains the window.
   NSScreen* screen = [window screen];
-  if (screen == nil)
+  if (screen == nil) {
     screen = [NSScreen mainScreen];
+  }
   NSRect frame = [screen frame];
   NSRect visibleFrame = [screen visibleFrame];
 
@@ -82,10 +84,11 @@ void WindowTestRunnerMac::Restore(CefRefPtr<CefBrowser> browser) {
   REQUIRE_MAIN_THREAD();
 
   NSWindow* window = GetWindow(browser);
-  if ([window isMiniaturized])
+  if ([window isMiniaturized]) {
     [window deminiaturize:nil];
-  else if ([window isZoomed])
+  } else if ([window isZoomed]) {
     [window performZoom:nil];
+  }
 }
 
 }  // namespace window_test
diff --git a/tests/cefclient/browser/window_test_runner_win.cc b/tests/cefclient/browser/window_test_runner_win.cc
index 8a8740d85..d94e89802 100644
--- a/tests/cefclient/browser/window_test_runner_win.cc
+++ b/tests/cefclient/browser/window_test_runner_win.cc
@@ -21,10 +21,11 @@ void Toggle(HWND root_hwnd, UINT nCmdShow) {
   WINDOWPLACEMENT placement;
   ::GetWindowPlacement(root_hwnd, &placement);
 
-  if (placement.showCmd == nCmdShow)
+  if (placement.showCmd == nCmdShow) {
     ::ShowWindow(root_hwnd, SW_RESTORE);
-  else
+  } else {
     ::ShowWindow(root_hwnd, nCmdShow);
+  }
 }
 
 void SetPosImpl(CefRefPtr<CefBrowser> browser,
@@ -33,8 +34,9 @@ void SetPosImpl(CefRefPtr<CefBrowser> browser,
                 int width,
                 int height) {
   HWND root_hwnd = GetRootHwnd(browser);
-  if (!root_hwnd)
+  if (!root_hwnd) {
     return;
+  }
 
   // Retrieve current window placement information.
   WINDOWPLACEMENT placement;
@@ -73,22 +75,25 @@ void SetPosImpl(CefRefPtr<CefBrowser> browser,
 
 void MinimizeImpl(CefRefPtr<CefBrowser> browser) {
   HWND root_hwnd = GetRootHwnd(browser);
-  if (!root_hwnd)
+  if (!root_hwnd) {
     return;
+  }
   Toggle(root_hwnd, SW_MINIMIZE);
 }
 
 void MaximizeImpl(CefRefPtr<CefBrowser> browser) {
   HWND root_hwnd = GetRootHwnd(browser);
-  if (!root_hwnd)
+  if (!root_hwnd) {
     return;
+  }
   Toggle(root_hwnd, SW_MAXIMIZE);
 }
 
 void RestoreImpl(CefRefPtr<CefBrowser> browser) {
   HWND root_hwnd = GetRootHwnd(browser);
-  if (!root_hwnd)
+  if (!root_hwnd) {
     return;
+  }
   ::ShowWindow(root_hwnd, SW_RESTORE);
 }
 
diff --git a/tests/cefclient/cefclient_gtk.cc b/tests/cefclient/cefclient_gtk.cc
index 92b6f9843..f0237a5d9 100644
--- a/tests/cefclient/cefclient_gtk.cc
+++ b/tests/cefclient/cefclient_gtk.cc
@@ -79,8 +79,9 @@ int RunMain(int argc, char* argv[]) {
 
   // Execute the secondary process, if any.
   int exit_code = CefExecuteProcess(main_args, app, nullptr);
-  if (exit_code >= 0)
+  if (exit_code >= 0) {
     return exit_code;
+  }
 
   // Create the main context object.
   auto context = std::make_unique<MainContextImpl>(command_line, true);
@@ -106,12 +107,13 @@ int RunMain(int argc, char* argv[]) {
 
   // Create the main message loop object.
   std::unique_ptr<MainMessageLoop> message_loop;
-  if (settings.multi_threaded_message_loop)
+  if (settings.multi_threaded_message_loop) {
     message_loop.reset(new MainMessageLoopMultithreadedGtk);
-  else if (settings.external_message_pump)
+  } else if (settings.external_message_pump) {
     message_loop = MainMessageLoopExternalPump::Create();
-  else
+  } else {
     message_loop.reset(new MainMessageLoopStd);
+  }
 
   // Initialize CEF.
   context->Initialize(main_args, settings, app, nullptr);
diff --git a/tests/cefclient/cefclient_mac.mm b/tests/cefclient/cefclient_mac.mm
index afeb3121b..b963ec2b8 100644
--- a/tests/cefclient/cefclient_mac.mm
+++ b/tests/cefclient/cefclient_mac.mm
@@ -22,8 +22,9 @@ namespace {
 NSMenuItem* GetMenuBarMenuWithTag(NSInteger tag) {
   NSMenu* main_menu = [[NSApplication sharedApplication] mainMenu];
   NSInteger found_index = [main_menu indexOfItemWithTag:tag];
-  if (found_index >= 0)
+  if (found_index >= 0) {
     return [main_menu itemAtIndex:found_index];
+  }
   return nil;
 }
 
@@ -31,8 +32,9 @@ NSMenuItem* GetMenuBarMenuWithTag(NSInteger tag) {
 NSMenuItem* GetMenuItemWithAction(NSMenu* menu, SEL action_selector) {
   for (NSInteger i = 0; i < menu.numberOfItems; ++i) {
     NSMenuItem* item = [menu itemAtIndex:i];
-    if (item.action == action_selector)
+    if (item.action == action_selector) {
       return item;
+    }
   }
   return nil;
 }
@@ -209,12 +211,14 @@ NSMenuItem* GetMenuItemWithAction(NSMenu* menu, SEL action_selector) {
     if (tests_menu) {
       NSMenuItem* set_fps_item = GetMenuItemWithAction(
           tests_menu.submenu, @selector(menuTestsSetFPS:));
-      if (set_fps_item)
+      if (set_fps_item) {
         [tests_menu.submenu removeItem:set_fps_item];
+      }
       NSMenuItem* set_scale_factor_item = GetMenuItemWithAction(
           tests_menu.submenu, @selector(menuTestsSetScaleFactor:));
-      if (set_scale_factor_item)
+      if (set_scale_factor_item) {
         [tests_menu.submenu removeItem:set_scale_factor_item];
+      }
     }
   }
 
@@ -239,12 +243,14 @@ NSMenuItem* GetMenuItemWithAction(NSMenu* menu, SEL action_selector) {
   // Retrieve the active RootWindow.
   auto root_window =
       client::MainContext::Get()->GetRootWindowManager()->GetActiveRootWindow();
-  if (!root_window)
+  if (!root_window) {
     return;
+  }
 
   CefRefPtr<CefBrowser> browser = root_window->GetBrowser();
-  if (browser.get())
+  if (browser.get()) {
     client::test_runner::RunTest(browser, command_id);
+  }
 }
 
 - (IBAction)menuTestsGetText:(id)sender {
@@ -319,8 +325,9 @@ NSMenuItem* GetMenuItemWithAction(NSMenu* menu, SEL action_selector) {
   // Retrieve the active RootWindow.
   auto root_window =
       client::MainContext::Get()->GetRootWindowManager()->GetActiveRootWindow();
-  if (!root_window)
+  if (!root_window) {
     return;
+  }
 
   CefRefPtr<CefBrowser> browser = root_window->GetBrowser();
   if (browser.get()) {
@@ -343,8 +350,9 @@ int RunMain(int argc, char* argv[]) {
   // Load the CEF framework library at runtime instead of linking directly
   // as required by the macOS sandbox implementation.
   CefScopedLibraryLoader library_loader;
-  if (!library_loader.LoadInMain())
+  if (!library_loader.LoadInMain()) {
     return 1;
+  }
 
   int result = -1;
 
@@ -368,8 +376,9 @@ int RunMain(int argc, char* argv[]) {
     CefRefPtr<CefApp> app;
     ClientApp::ProcessType process_type =
         ClientApp::GetProcessType(command_line);
-    if (process_type == ClientApp::BrowserProcess)
+    if (process_type == ClientApp::BrowserProcess) {
       app = new ClientAppBrowser();
+    }
 
     // Create the main context object.
     std::unique_ptr<MainContextImpl> context(
@@ -389,10 +398,11 @@ int RunMain(int argc, char* argv[]) {
 
     // Create the main message loop object.
     std::unique_ptr<MainMessageLoop> message_loop;
-    if (settings.external_message_pump)
+    if (settings.external_message_pump) {
       message_loop = MainMessageLoopExternalPump::Create();
-    else
+    } else {
       message_loop.reset(new MainMessageLoopStd);
+    }
 
     // Initialize CEF.
     context->Initialize(main_args, settings, app, nullptr);
diff --git a/tests/cefclient/cefclient_win.cc b/tests/cefclient/cefclient_win.cc
index b36b0db3a..d41108ea5 100644
--- a/tests/cefclient/cefclient_win.cc
+++ b/tests/cefclient/cefclient_win.cc
@@ -56,17 +56,19 @@ int RunMain(HINSTANCE hInstance, int nCmdShow) {
   // Create a ClientApp of the correct type.
   CefRefPtr<CefApp> app;
   ClientApp::ProcessType process_type = ClientApp::GetProcessType(command_line);
-  if (process_type == ClientApp::BrowserProcess)
+  if (process_type == ClientApp::BrowserProcess) {
     app = new ClientAppBrowser();
-  else if (process_type == ClientApp::RendererProcess)
+  } else if (process_type == ClientApp::RendererProcess) {
     app = new ClientAppRenderer();
-  else if (process_type == ClientApp::OtherProcess)
+  } else if (process_type == ClientApp::OtherProcess) {
     app = new ClientAppOther();
+  }
 
   // Execute the secondary process, if any.
   int exit_code = CefExecuteProcess(main_args, app, sandbox_info);
-  if (exit_code >= 0)
+  if (exit_code >= 0) {
     return exit_code;
+  }
 
   // Create the main context object.
   auto context = std::make_unique<MainContextImpl>(command_line, true);
@@ -82,12 +84,13 @@ int RunMain(HINSTANCE hInstance, int nCmdShow) {
 
   // Create the main message loop object.
   std::unique_ptr<MainMessageLoop> message_loop;
-  if (settings.multi_threaded_message_loop)
+  if (settings.multi_threaded_message_loop) {
     message_loop.reset(new MainMessageLoopMultithreadedWin);
-  else if (settings.external_message_pump)
+  } else if (settings.external_message_pump) {
     message_loop = MainMessageLoopExternalPump::Create();
-  else
+  } else {
     message_loop.reset(new MainMessageLoopStd);
+  }
 
   // Initialize CEF.
   context->Initialize(main_args, settings, app, sandbox_info);
diff --git a/tests/cefsimple/cefsimple_mac.mm b/tests/cefsimple/cefsimple_mac.mm
index 35c00d1a6..6d2c9eda0 100644
--- a/tests/cefsimple/cefsimple_mac.mm
+++ b/tests/cefsimple/cefsimple_mac.mm
@@ -99,8 +99,9 @@
 
 - (void)tryToTerminateApplication:(NSApplication*)app {
   SimpleHandler* handler = SimpleHandler::GetInstance();
-  if (handler && !handler->IsClosing())
+  if (handler && !handler->IsClosing()) {
     handler->CloseAllBrowsers(false);
+  }
 }
 
 - (NSApplicationTerminateReply)applicationShouldTerminate:
@@ -114,8 +115,9 @@ int main(int argc, char* argv[]) {
   // Load the CEF framework library at runtime instead of linking directly
   // as required by the macOS sandbox implementation.
   CefScopedLibraryLoader library_loader;
-  if (!library_loader.LoadInMain())
+  if (!library_loader.LoadInMain()) {
     return 1;
+  }
 
   // Provide CEF with command-line arguments.
   CefMainArgs main_args(argc, argv);
diff --git a/tests/cefsimple/process_helper_mac.cc b/tests/cefsimple/process_helper_mac.cc
index 224593dd5..bc6d83c02 100644
--- a/tests/cefsimple/process_helper_mac.cc
+++ b/tests/cefsimple/process_helper_mac.cc
@@ -17,15 +17,17 @@ int main(int argc, char* argv[]) {
 #if defined(CEF_USE_SANDBOX)
   // Initialize the macOS sandbox for this helper process.
   CefScopedSandboxContext sandbox_context;
-  if (!sandbox_context.Initialize(argc, argv))
+  if (!sandbox_context.Initialize(argc, argv)) {
     return 1;
+  }
 #endif
 
   // Load the CEF framework library at runtime instead of linking directly
   // as required by the macOS sandbox implementation.
   CefScopedLibraryLoader library_loader;
-  if (!library_loader.LoadInHelper())
+  if (!library_loader.LoadInHelper()) {
     return 1;
+  }
 
   // Provide CEF with command-line arguments.
   CefMainArgs main_args(argc, argv);
diff --git a/tests/cefsimple/simple_app.cc b/tests/cefsimple/simple_app.cc
index 8562fafe9..72556cf5a 100644
--- a/tests/cefsimple/simple_app.cc
+++ b/tests/cefsimple/simple_app.cc
@@ -38,8 +38,9 @@ class SimpleWindowDelegate : public CefWindowDelegate {
   bool CanClose(CefRefPtr<CefWindow> window) override {
     // Allow the window to close if the browser says it's OK.
     CefRefPtr<CefBrowser> browser = browser_view_->GetBrowser();
-    if (browser)
+    if (browser) {
       return browser->GetHost()->TryCloseBrowser();
+    }
     return true;
   }
 
@@ -101,8 +102,9 @@ void SimpleApp::OnContextInitialized() {
   // Check if a "--url=" value was provided via the command-line. If so, use
   // that instead of the default URL.
   url = command_line->GetSwitchValue("url");
-  if (url.empty())
+  if (url.empty()) {
     url = "http://www.google.com";
+  }
 
   if (use_views) {
     // Create the BrowserView.
diff --git a/tests/cefsimple/simple_handler.cc b/tests/cefsimple/simple_handler.cc
index fd1864897..e7d977f5e 100644
--- a/tests/cefsimple/simple_handler.cc
+++ b/tests/cefsimple/simple_handler.cc
@@ -53,8 +53,9 @@ void SimpleHandler::OnTitleChange(CefRefPtr<CefBrowser> browser,
         CefBrowserView::GetForBrowser(browser);
     if (browser_view) {
       CefRefPtr<CefWindow> window = browser_view->GetWindow();
-      if (window)
+      if (window) {
         window->SetTitle(title);
+      }
     }
   } else if (!IsChromeRuntimeEnabled()) {
     // Set the title of the window using platform APIs.
@@ -111,12 +112,14 @@ void SimpleHandler::OnLoadError(CefRefPtr<CefBrowser> browser,
   CEF_REQUIRE_UI_THREAD();
 
   // Allow Chrome to show the error page.
-  if (IsChromeRuntimeEnabled())
+  if (IsChromeRuntimeEnabled()) {
     return;
+  }
 
   // Don't display an error for downloaded files.
-  if (errorCode == ERR_ABORTED)
+  if (errorCode == ERR_ABORTED) {
     return;
+  }
 
   // Display a load error message using a data: URI.
   std::stringstream ss;
@@ -136,12 +139,14 @@ void SimpleHandler::CloseAllBrowsers(bool force_close) {
     return;
   }
 
-  if (browser_list_.empty())
+  if (browser_list_.empty()) {
     return;
+  }
 
   BrowserList::const_iterator it = browser_list_.begin();
-  for (; it != browser_list_.end(); ++it)
+  for (; it != browser_list_.end(); ++it) {
     (*it)->GetHost()->CloseBrowser(force_close);
+  }
 }
 
 // static
diff --git a/tests/cefsimple/simple_handler_linux.cc b/tests/cefsimple/simple_handler_linux.cc
index 28e432ef2..92d9a163d 100644
--- a/tests/cefsimple/simple_handler_linux.cc
+++ b/tests/cefsimple/simple_handler_linux.cc
@@ -25,16 +25,18 @@ void SimpleHandler::PlatformTitleChange(CefRefPtr<CefBrowser> browser,
 
   // Retrieve the X11 window handle for the browser.
   ::Window window = browser->GetHost()->GetWindowHandle();
-  if (window == kNullWindowHandle)
+  if (window == kNullWindowHandle) {
     return;
+  }
 
   // Retrieve the atoms required by the below XChangeProperty call.
   const char* kAtoms[] = {"_NET_WM_NAME", "UTF8_STRING"};
   Atom atoms[2];
   int result =
       XInternAtoms(display, const_cast<char**>(kAtoms), 2, false, atoms);
-  if (!result)
+  if (!result) {
     NOTREACHED();
+  }
 
   // Set the window title.
   XChangeProperty(display, window, atoms[0], atoms[1], 8, PropModeReplace,
diff --git a/tests/cefsimple/simple_handler_win.cc b/tests/cefsimple/simple_handler_win.cc
index 1bc4de44b..3811c67a1 100644
--- a/tests/cefsimple/simple_handler_win.cc
+++ b/tests/cefsimple/simple_handler_win.cc
@@ -12,6 +12,7 @@
 void SimpleHandler::PlatformTitleChange(CefRefPtr<CefBrowser> browser,
                                         const CefString& title) {
   CefWindowHandle hwnd = browser->GetHost()->GetWindowHandle();
-  if (hwnd)
+  if (hwnd) {
     SetWindowText(hwnd, std::wstring(title).c_str());
+  }
 }
diff --git a/tests/ceftests/audio_output_unittest.cc b/tests/ceftests/audio_output_unittest.cc
index 1c659c4b2..c49a44568 100644
--- a/tests/ceftests/audio_output_unittest.cc
+++ b/tests/ceftests/audio_output_unittest.cc
@@ -1055,8 +1055,9 @@ class AudioTogglePlaybackTest : public AudioTestHandler {
 
   void OnAudioStreamStopped(CefRefPtr<CefBrowser> browser) override {
     EXPECT_EQ(start_count_, ++stop_count_);
-    if (stop_count_ == kToggleCount)
+    if (stop_count_ == kToggleCount) {
       AudioTestHandler::OnAudioStreamStopped(browser);
+    }
   }
 
  protected:
diff --git a/tests/ceftests/cookie_unittest.cc b/tests/ceftests/cookie_unittest.cc
index 7985b4e21..c57336518 100644
--- a/tests/ceftests/cookie_unittest.cc
+++ b/tests/ceftests/cookie_unittest.cc
@@ -111,8 +111,9 @@ class TestVisitor : public CefCookieVisitor {
              bool& deleteCookie) override {
     EXPECT_TRUE(CefCurrentlyOn(TID_UI));
     cookies_->push_back(cookie);
-    if (delete_cookies_)
+    if (delete_cookies_) {
       deleteCookie = true;
+    }
     return true;
   }
 
@@ -167,8 +168,9 @@ void CreateCookie(CefRefPtr<CefCookieManager> manager,
                   CefRefPtr<CefWaitableEvent> event) {
   CefString(&cookie.name).FromASCII("my_cookie");
   CefString(&cookie.value).FromASCII("My Value");
-  if (withDomain)
+  if (withDomain) {
     CefString(&cookie.domain).FromASCII(kTestDomain);
+  }
   CefString(&cookie.path).FromASCII(kTestPath);
   if (!sessionCookie) {
     cookie.has_expires = true;
@@ -242,16 +244,18 @@ void GetCookie(CefRefPtr<CefCookieManager> manager,
   VisitUrlCookies(manager, kTestUrl, false, cookies, deleteCookies, event);
 
   EXPECT_EQ(1U, cookies.size());
-  if (cookies.size() != 1U)
+  if (cookies.size() != 1U) {
     return;
+  }
 
   const CefCookie& cookie_read = cookies[0];
   EXPECT_EQ(CefString(&cookie_read.name), "my_cookie");
   EXPECT_EQ(CefString(&cookie_read.value), "My Value");
-  if (withDomain)
+  if (withDomain) {
     EXPECT_EQ(CefString(&cookie_read.domain), ".www.test.com");
-  else
+  } else {
     EXPECT_EQ(CefString(&cookie_read.domain), kTestDomain);
+  }
   EXPECT_EQ(CefString(&cookie_read.path), kTestPath);
   EXPECT_EQ(cookie.has_expires, cookie_read.has_expires);
   EXPECT_EQ(cookie.expires.val, cookie_read.expires.val);
@@ -379,8 +383,9 @@ void TestMultipleCookies(CefRefPtr<CefCookieManager> manager,
   VisitUrlCookies(manager, kTestUrl, false, cookies, false, event);
 
   EXPECT_EQ(3U, cookies.size());
-  if (cookies.size() != 3U)
+  if (cookies.size() != 3U) {
     return;
+  }
 
   EXPECT_EQ(CefString(&cookies[0].name), "my_cookie0");
   EXPECT_EQ(CefString(&cookies[1].name), "my_cookie2");
@@ -457,8 +462,9 @@ void TestAllCookies(CefRefPtr<CefCookieManager> manager,
   VisitAllCookies(manager, cookies, false, event);
 
   EXPECT_EQ(2U, cookies.size());
-  if (cookies.size() != 2U)
+  if (cookies.size() != 2U) {
     return;
+  }
 
   EXPECT_EQ(CefString(&cookies[0].name), "my_cookie1");
   EXPECT_EQ(CefString(&cookies[0].value), "My Value 1");
@@ -472,8 +478,9 @@ void TestAllCookies(CefRefPtr<CefCookieManager> manager,
   VisitUrlCookies(manager, kUrl1, false, cookies, false, event);
 
   EXPECT_EQ(1U, cookies.size());
-  if (cookies.size() != 1U)
+  if (cookies.size() != 1U) {
     return;
+  }
 
   EXPECT_EQ(CefString(&cookies[0].name), "my_cookie1");
   EXPECT_EQ(CefString(&cookies[0].value), "My Value 1");
@@ -483,8 +490,9 @@ void TestAllCookies(CefRefPtr<CefCookieManager> manager,
   VisitUrlCookies(manager, kUrl2, false, cookies, false, event);
 
   EXPECT_EQ(1U, cookies.size());
-  if (cookies.size() != 1U)
+  if (cookies.size() != 1U) {
     return;
+  }
 
   EXPECT_EQ(CefString(&cookies[0].name), "my_cookie2");
   EXPECT_EQ(CefString(&cookies[0].value), "My Value 2");
@@ -743,8 +751,9 @@ class CookieTestSchemeHandler : public TestHandler {
         CefRequest::HeaderMap headerMap;
         request->GetHeaderMap(headerMap);
         CefRequest::HeaderMap::iterator it = headerMap.find("Cookie");
-        if (it != headerMap.end() && it->second == "name2=value2")
+        if (it != headerMap.end() && it->second == "name2=value2") {
           handler_->got_process_request_cookie_.yes();
+        }
       }
 
       // Continue immediately.
@@ -819,8 +828,9 @@ class CookieTestSchemeHandler : public TestHandler {
         CefRequest::HeaderMap headerMap;
         request->GetHeaderMap(headerMap);
         CefRequest::HeaderMap::iterator it = headerMap.find("Cookie");
-        if (it != headerMap.end() && it->second == "name2=value2")
+        if (it != headerMap.end() && it->second == "name2=value2") {
           handler_->got_create_cookie_.yes();
+        }
       }
 
       return new SchemeHandler(handler_);
@@ -1430,12 +1440,14 @@ class CookieAccessTestHandler : public RoutingTestHandler,
         test_backend_(test_backend),
         scheme_(custom_scheme ? kCustomCookieScheme : GetCookieAccessScheme()),
         use_global_(use_global) {
-    if (test_mode_ == BLOCK_ALL_COOKIES)
+    if (test_mode_ == BLOCK_ALL_COOKIES) {
       CHECK(!use_global_);
-    else if (test_mode_ == ALLOW_NO_HANDLER)
+    } else if (test_mode_ == ALLOW_NO_HANDLER) {
       CHECK_NE(RESOURCE_HANDLER, test_backend_);
-    if (test_backend_ == SERVER)
+    }
+    if (test_backend_ == SERVER) {
       CHECK(!custom_scheme);
+    }
   }
 
   void RunTest() override {
@@ -1553,8 +1565,9 @@ class CookieAccessTestHandler : public RoutingTestHandler,
       CefRefPtr<CefRequest> request) override {
     EXPECT_IO_THREAD();
 
-    if (test_mode_ == ALLOW_NO_FILTER)
+    if (test_mode_ == ALLOW_NO_FILTER) {
       return nullptr;
+    }
 
     return this;
   }
@@ -1567,8 +1580,9 @@ class CookieAccessTestHandler : public RoutingTestHandler,
       bool is_download,
       const CefString& request_initiator,
       bool& disable_default_handling) override {
-    if (test_mode_ == ALLOW_NO_HANDLER)
+    if (test_mode_ == ALLOW_NO_HANDLER) {
       return nullptr;
+    }
 
     return this;
   }
@@ -1763,10 +1777,11 @@ class CookieAccessTestHandler : public RoutingTestHandler,
                  bool& deleteCookie) override {
         const std::string& name = CefString(&cookie.name);
         const std::string& value = CefString(&cookie.value);
-        if (name == "name_js" && value == "value_js")
+        if (name == "name_js" && value == "value_js") {
           handler_->cookie_js3_ct_++;
-        else if (name == "name_net" && value == "value_net")
+        } else if (name == "name_net" && value == "value_net") {
           handler_->cookie_net3_ct_++;
+        }
 
         // Clean up the cookies.
         deleteCookie = true;
@@ -2215,10 +2230,11 @@ class CookieRestartTestHandler : public RoutingTestHandler,
                  bool& deleteCookie) override {
         const std::string& name = CefString(&cookie.name);
         const std::string& value = CefString(&cookie.value);
-        if (name == "name_js" && value == "value_js")
+        if (name == "name_js" && value == "value_js") {
           handler_->cookie_manager_js_ct_++;
-        else if (name == "name_net" && value == "value_net")
+        } else if (name == "name_net" && value == "value_net") {
           handler_->cookie_manager_net_ct_++;
+        }
 
         // Clean up the cookies.
         deleteCookie = true;
diff --git a/tests/ceftests/cors_unittest.cc b/tests/ceftests/cors_unittest.cc
index 4f0ef72a7..ea9ff544e 100644
--- a/tests/ceftests/cors_unittest.cc
+++ b/tests/ceftests/cors_unittest.cc
@@ -224,8 +224,9 @@ struct TestSetup {
 
   Resource* GetResource(const std::string& url,
                         const std::string& method = std::string()) const {
-    if (resources.empty())
+    if (resources.empty()) {
       return nullptr;
+    }
 
     std::set<std::string> matching_methods;
     if (method.empty()) {
@@ -266,8 +267,9 @@ struct TestSetup {
     ResourceList::const_iterator it = resources.begin();
     for (; it != resources.end(); ++it) {
       Resource* resource = *it;
-      if (resource->handler == HandlerType::SERVER)
+      if (resource->handler == HandlerType::SERVER) {
         return true;
+      }
     }
     return false;
   }
@@ -277,8 +279,9 @@ struct TestSetup {
     ResourceList::const_iterator it = resources.begin();
     for (; it != resources.end(); ++it) {
       Resource* resource = *it;
-      if (!resource->IsDone())
+      if (!resource->IsDone()) {
         return false;
+      }
     }
     return true;
   }
@@ -410,8 +413,9 @@ class CorsTestHandler : public RoutingTestHandler {
                  int httpStatusCode) override {
     const std::string& url = frame->GetURL();
     Resource* resource = GetResource(url);
-    if (!resource)
+    if (!resource) {
       return;
+    }
 
     const int expected_status = resource->response->GetStatus();
     if (url == main_url_ || expected_status != 200) {
@@ -428,8 +432,9 @@ class CorsTestHandler : public RoutingTestHandler {
                    const CefString& errorText,
                    const CefString& failedUrl) override {
     Resource* resource = GetResource(failedUrl);
-    if (!resource)
+    if (!resource) {
       return;
+    }
 
     const cef_errorcode_t expected_error = resource->response->GetError();
 
@@ -448,16 +453,18 @@ class CorsTestHandler : public RoutingTestHandler {
                bool persistent,
                CefRefPtr<Callback> callback) override {
     Resource* resource = GetResource(frame->GetURL());
-    if (!resource)
+    if (!resource) {
       return false;
+    }
 
     if (request.ToString() == kSuccessMsg ||
         request.ToString() == kFailureMsg) {
       callback->Success("");
-      if (request.ToString() == kSuccessMsg)
+      if (request.ToString() == kSuccessMsg) {
         resource->success_query_ct++;
-      else
+      } else {
         resource->failure_query_ct++;
+      }
       TriggerDestroyTestIfDone();
       return true;
     }
@@ -504,8 +511,9 @@ class CorsTestHandler : public RoutingTestHandler {
 
   void DestroyTestIfDone() {
     CEF_REQUIRE_UI_THREAD();
-    if (shutting_down_)
+    if (shutting_down_) {
       return;
+    }
 
     if (setup_->IsDone()) {
       shutting_down_ = true;
@@ -987,21 +995,24 @@ struct SubResource : CookieResource {
   }
 
   bool VerifyRequest(CefRefPtr<CefRequest> request) const override {
-    if (!CookieResource::VerifyRequest(request))
+    if (!CookieResource::VerifyRequest(request)) {
       return false;
+    }
 
     const std::string& request_method = request->GetMethod();
     EXPECT_STREQ(method.c_str(), request_method.c_str()) << GetPathURL();
-    if (request_method != method)
+    if (request_method != method) {
       return false;
+    }
 
     // Verify that the "Origin" header contains the expected value.
     const std::string& origin = request->GetHeaderByName("Origin");
     const std::string& expected_origin =
         is_cross_origin ? main_origin : std::string();
     EXPECT_STREQ(expected_origin.c_str(), origin.c_str()) << GetPathURL();
-    if (expected_origin != origin)
+    if (expected_origin != origin) {
       return false;
+    }
 
     // Verify that the "X-Unsafe-Header" header contains the expected value.
     const std::string& unsafe_header =
@@ -1037,26 +1048,30 @@ struct PreflightResource : Resource {
   bool VerifyRequest(CefRefPtr<CefRequest> request) const override {
     const std::string& request_method = request->GetMethod();
     EXPECT_STREQ(method.c_str(), request_method.c_str()) << GetPathURL();
-    if (request_method != method)
+    if (request_method != method) {
       return false;
+    }
 
     const std::string& origin = request->GetHeaderByName("Origin");
     EXPECT_STREQ(main_origin.c_str(), origin.c_str()) << GetPathURL();
-    if (main_origin != origin)
+    if (main_origin != origin) {
       return false;
+    }
 
     const std::string& ac_request_method =
         request->GetHeaderByName("Access-Control-Request-Method");
     EXPECT_STREQ(kSubRequestMethod, ac_request_method.c_str()) << GetPathURL();
-    if (ac_request_method != kSubRequestMethod)
+    if (ac_request_method != kSubRequestMethod) {
       return false;
+    }
 
     const std::string& ac_request_headers =
         request->GetHeaderByName("Access-Control-Request-Headers");
     EXPECT_STREQ(kSubUnsafeHeaderName, ac_request_headers.c_str())
         << GetPathURL();
-    if (ac_request_headers != kSubUnsafeHeaderName)
+    if (ac_request_headers != kSubUnsafeHeaderName) {
       return false;
+    }
 
     return true;
   }
@@ -1496,8 +1511,9 @@ struct RedirectGetResource : CookieResource {
   RedirectGetResource() {}
 
   bool VerifyRequest(CefRefPtr<CefRequest> request) const override {
-    if (!CookieResource::VerifyRequest(request))
+    if (!CookieResource::VerifyRequest(request)) {
       return false;
+    }
 
     // The "Origin" header should never be present for a redirect.
     const std::string& origin = request->GetHeaderByName("Origin");
@@ -1509,12 +1525,13 @@ struct RedirectGetResource : CookieResource {
 void SetupRedirectResponse(RedirectMode mode,
                            const std::string& redirect_url,
                            CefRefPtr<CefResponse> response) {
-  if (mode == RedirectMode::MODE_302)
+  if (mode == RedirectMode::MODE_302) {
     response->SetStatus(302);
-  else if (mode == RedirectMode::MODE_307)
+  } else if (mode == RedirectMode::MODE_307) {
     response->SetStatus(307);
-  else
+  } else {
     NOTREACHED();
+  }
 
   response->SetHeaderByName("Location", redirect_url,
                             /*override=*/false);
@@ -1655,8 +1672,9 @@ struct PostResource : CookieResource {
   }
 
   bool VerifyRequest(CefRefPtr<CefRequest> request) const override {
-    if (!CookieResource::VerifyRequest(request))
+    if (!CookieResource::VerifyRequest(request)) {
       return false;
+    }
 
     // The "Origin" header should be present if the request is POST, and was not
     // redirected cross-origin.
@@ -1672,8 +1690,9 @@ struct PostResource : CookieResource {
 
     const std::string& origin = request->GetHeaderByName("Origin");
     EXPECT_STREQ(expected_origin.c_str(), origin.c_str()) << GetPathURL();
-    if (expected_origin != origin)
+    if (expected_origin != origin) {
       return false;
+    }
 
     const std::string& req_method = request->GetMethod();
     const bool has_post_data = request->GetPostData() != nullptr;
diff --git a/tests/ceftests/devtools_message_unittest.cc b/tests/ceftests/devtools_message_unittest.cc
index 92257605e..0282f0c7a 100644
--- a/tests/ceftests/devtools_message_unittest.cc
+++ b/tests/ceftests/devtools_message_unittest.cc
@@ -233,8 +233,9 @@ class DevToolsMessageTestHandler : public TestHandler {
   void OnMethodResult(const MethodResult& result) {
     EXPECT_EQ(pending_result_.message_id, result.message_id)
         << "with message=" << pending_message_;
-    if (result.message_id != pending_result_.message_id)
+    if (result.message_id != pending_result_.message_id) {
       return;
+    }
 
     EXPECT_EQ(pending_result_.success, result.success)
         << "with message=" << pending_message_;
@@ -255,8 +256,9 @@ class DevToolsMessageTestHandler : public TestHandler {
   }
 
   void OnEvent(const Event& event) {
-    if (event.method != pending_event_.method)
+    if (event.method != pending_event_.method) {
       return;
+    }
 
     EXPECT_TRUE(event.params.find(pending_event_.params) == 0)
         << "with method=" << event.method
diff --git a/tests/ceftests/dialog_unittest.cc b/tests/ceftests/dialog_unittest.cc
index a629d82ec..e80dd26aa 100644
--- a/tests/ceftests/dialog_unittest.cc
+++ b/tests/ceftests/dialog_unittest.cc
@@ -81,10 +81,11 @@ class DialogTestHandler : public TestHandler {
   }
 
   void ExecuteCallback(CefRefPtr<CefFileDialogCallback> callback) {
-    if (config_.callback_cancel)
+    if (config_.callback_cancel) {
       callback->Cancel();
-    else
+    } else {
       callback->Continue(config_.callback_paths);
+    }
   }
 
   // CefDialogHandler
diff --git a/tests/ceftests/display_unittest.cc b/tests/ceftests/display_unittest.cc
index 0190e1691..563f6cb68 100644
--- a/tests/ceftests/display_unittest.cc
+++ b/tests/ceftests/display_unittest.cc
@@ -55,8 +55,9 @@ class TitleTestHandler : public TestHandler {
                      const CefString& title) override {
     // Ignore the 2nd OnTitleChange call which arrives after navigation
     // completion.
-    if (got_title_change_)
+    if (got_title_change_) {
       return;
+    }
 
     std::string title_str = title;
     if (step_ == 0 || step_ == 2) {
@@ -81,8 +82,9 @@ class TitleTestHandler : public TestHandler {
                             bool isLoading,
                             bool canGoBack,
                             bool canGoForward) override {
-    if (isLoading)
+    if (isLoading) {
       return;
+    }
 
     // Call NextIfReady asynchronously because an additional call to
     // OnTitleChange will be triggered later in the current call stack due to
@@ -95,8 +97,9 @@ class TitleTestHandler : public TestHandler {
 
  private:
   void NextIfReady(CefRefPtr<CefBrowser> browser) {
-    if (!got_title_change_ || !got_loading_state_change_)
+    if (!got_title_change_ || !got_loading_state_change_) {
       return;
+    }
 
     got_title_change_ = false;
     got_loading_state_change_ = false;
@@ -120,8 +123,9 @@ class TitleTestHandler : public TestHandler {
   }
 
   void DestroyTest() override {
-    for (int i = 0; i < 5; ++i)
+    for (int i = 0; i < 5; ++i) {
       EXPECT_TRUE(got_title_[i]) << "step " << i;
+    }
 
     TestHandler::DestroyTest();
   }
@@ -287,8 +291,9 @@ class ConsoleTestHandler : public TestHandler {
                             bool isLoading,
                             bool canGoBack,
                             bool canGoForward) override {
-    if (isLoading)
+    if (isLoading) {
       return;
+    }
 
     // Print console message after loading.
     browser->GetMainFrame()->ExecuteJavaScript("printMessage()", config_.source,
@@ -485,8 +490,9 @@ class LoadingProgressTestHandler : public TestHandler {
                             bool isLoading,
                             bool canGoBack,
                             bool canGoForward) override {
-    if (isLoading)
+    if (isLoading) {
       return;
+    }
 
     DestroyTest();
   }
diff --git a/tests/ceftests/dom_unittest.cc b/tests/ceftests/dom_unittest.cc
index c99297ebf..0be485c7b 100644
--- a/tests/ceftests/dom_unittest.cc
+++ b/tests/ceftests/dom_unittest.cc
@@ -211,10 +211,11 @@ class TestDOMVisitor : public CefDOMVisitor {
   }
 
   void Visit(CefRefPtr<CefDOMDocument> document) override {
-    if (test_type_ == DOM_TEST_STRUCTURE)
+    if (test_type_ == DOM_TEST_STRUCTURE) {
       TestStructure(document);
-    else if (test_type_ == DOM_TEST_MODIFY)
+    } else if (test_type_ == DOM_TEST_MODIFY) {
       TestModify(document);
+    }
 
     DestroyTest();
   }
@@ -330,8 +331,9 @@ class TestDOMHandler : public TestHandler {
 
     got_message_.yes();
 
-    if (message->GetArgumentList()->GetBool(0))
+    if (message->GetArgumentList()->GetBool(0)) {
       got_success_.yes();
+    }
 
     // Test is complete.
     DestroyTest();
diff --git a/tests/ceftests/download_unittest.cc b/tests/ceftests/download_unittest.cc
index 842ae5598..ba261deff 100644
--- a/tests/ceftests/download_unittest.cc
+++ b/tests/ceftests/download_unittest.cc
@@ -396,8 +396,9 @@ class DownloadTestHandler : public TestHandler {
                          CefRefPtr<CefDownloadItemCallback> callback) override {
     EXPECT_TRUE(CefCurrentlyOn(TID_UI));
 
-    if (destroyed_)
+    if (destroyed_) {
       return;
+    }
 
     got_on_download_updated_.yes();
 
@@ -514,10 +515,11 @@ class DownloadTestHandler : public TestHandler {
       EXPECT_TRUE(got_on_download_updated_);
     }
 
-    if (test_mode_ == NAVIGATED)
+    if (test_mode_ == NAVIGATED) {
       EXPECT_TRUE(got_nav_load_);
-    else
+    } else {
       EXPECT_FALSE(got_nav_load_);
+    }
 
     if (!is_downloaded()) {
       // The download never completes.
diff --git a/tests/ceftests/draggable_regions_unittest.cc b/tests/ceftests/draggable_regions_unittest.cc
index 5b5251d47..f541731da 100644
--- a/tests/ceftests/draggable_regions_unittest.cc
+++ b/tests/ceftests/draggable_regions_unittest.cc
@@ -120,8 +120,9 @@ class DraggableRegionsTestHandler : public TestHandler,
       case kStepWithRegions:
       case kStepWithChangingRegions2:
         EXPECT_EQ(2U, regions.size()) << step_;
-        if (regions.size() != 2U)
+        if (regions.size() != 2U) {
           break;
+        }
         EXPECT_NEAR(50, regions[0].bounds.x, 1);
         EXPECT_NEAR(50, regions[0].bounds.y, 1);
         EXPECT_NEAR(200, regions[0].bounds.width, 1);
@@ -136,8 +137,9 @@ class DraggableRegionsTestHandler : public TestHandler,
       case kStepWithChangingRegions:
       case kStepWithChangingRegions3:
         EXPECT_EQ(2U, regions.size()) << step_;
-        if (regions.size() != 2U)
+        if (regions.size() != 2U) {
           break;
+        }
         EXPECT_EQ(0, regions[0].bounds.x);
         EXPECT_EQ(0, regions[0].bounds.y);
         EXPECT_NEAR(200, regions[0].bounds.width, 1);
diff --git a/tests/ceftests/extensions/background_unittest.cc b/tests/ceftests/extensions/background_unittest.cc
index 3b625817c..a043f1672 100644
--- a/tests/ceftests/extensions/background_unittest.cc
+++ b/tests/ceftests/extensions/background_unittest.cc
@@ -64,11 +64,13 @@ class BackgroundLoadUnloadTestHandler : public ExtensionTestHandler {
     EXPECT_TRUE(extension_->IsSame(extension));
 
     // The extension should no longer be registered with the context.
-    if (loader_request_context())
+    if (loader_request_context()) {
       VerifyExtensionInContext(extension, loader_request_context(), false,
                                true);
-    if (request_context() && !request_context_same_loader())
+    }
+    if (request_context() && !request_context_same_loader()) {
       VerifyExtensionInContext(extension, request_context(), false, false);
+    }
 
     extension_ = nullptr;
 
@@ -169,8 +171,9 @@ class BackgroundLoadUnloadTestHandler : public ExtensionTestHandler {
     TestDictionaryEqual(expected_manifest, extension->GetManifest());
 
     VerifyExtensionInContext(extension, loader_request_context(), true, true);
-    if (!request_context_same_loader())
+    if (!request_context_same_loader()) {
       VerifyExtensionInContext(extension, request_context(), true, false);
+    }
   }
 
   std::string GetExtensionURL(CefRefPtr<CefExtension> extension,
diff --git a/tests/ceftests/extensions/chrome_tabs_unittest.cc b/tests/ceftests/extensions/chrome_tabs_unittest.cc
index cb2bdfb2c..c40043e42 100644
--- a/tests/ceftests/extensions/chrome_tabs_unittest.cc
+++ b/tests/ceftests/extensions/chrome_tabs_unittest.cc
@@ -52,10 +52,11 @@ class TabsTestHandler : public ExtensionTestHandler {
     EXPECT_FALSE(extension_);
     extension_ = extension;
 
-    if (create_main_browser_first_)
+    if (create_main_browser_first_) {
       CreateBrowserForExtensionIfReady();
-    else
+    } else {
       CreateBrowserForExtension();
+    }
   }
 
   void OnExtensionUnloaded(CefRefPtr<CefExtension> extension) override {
@@ -168,8 +169,9 @@ class TabsTestHandler : public ExtensionTestHandler {
       EXPECT_TRUE(browser->IsSame(main_browser_));
       EXPECT_FALSE(got_main_body_onload_);
       got_main_body_onload_.yes();
-      if (create_main_browser_first_)
+      if (create_main_browser_first_) {
         CreateBrowserForExtensionIfReady();
+      }
       TriggerTabsApiJSFunctionIfReady();
       return true;
     }
@@ -298,8 +300,9 @@ class TabsTestHandler : public ExtensionTestHandler {
  private:
   void CreateBrowserForExtensionIfReady() {
     DCHECK(create_main_browser_first_);
-    if (extension_ && main_browser_)
+    if (extension_ && main_browser_) {
       CreateBrowserForExtension();
+    }
   }
 
   void CreateBrowserForExtension() {
@@ -317,8 +320,9 @@ class TabsTestHandler : public ExtensionTestHandler {
   }
 
   void TriggerTabsApiJSFunctionIfReady() {
-    if (got_main_body_onload_ && got_extension_body_onload_)
+    if (got_main_body_onload_ && got_extension_body_onload_) {
       TriggerTabsApiJSFunction();
+    }
   }
 
   void TriggerTabsApiJSFunction() {
@@ -513,8 +517,9 @@ class CreateTestHandler : public TabsTestHandler {
   }
 
   void TriggerDestroyTestIfReady() {
-    if (got_tab_callback_message_ && got_success_message())
+    if (got_tab_callback_message_ && got_success_message()) {
       TriggerDestroyTest();
+    }
   }
 
   CefRefPtr<CefBrowser> created_browser_;
diff --git a/tests/ceftests/extensions/extension_test_handler.cc b/tests/ceftests/extensions/extension_test_handler.cc
index a1234036e..22259c226 100644
--- a/tests/ceftests/extensions/extension_test_handler.cc
+++ b/tests/ceftests/extensions/extension_test_handler.cc
@@ -32,8 +32,9 @@ ExtensionTestHandler::~ExtensionTestHandler() {
 }
 
 void ExtensionTestHandler::RunTest() {
-  if (create_main_browser_)
+  if (create_main_browser_) {
     OnAddMainBrowserResources();
+  }
 
   CefRefPtr<CefRequestContextHandler> rc_handler;
   if (request_context_with_handler()) {
@@ -134,8 +135,9 @@ bool ExtensionTestHandler::OnQuery(CefRefPtr<CefBrowser> browser,
                                    const CefString& request,
                                    bool persistent,
                                    CefRefPtr<Callback> callback) {
-  if (OnMessage(browser, request))
+  if (OnMessage(browser, request)) {
     return true;
+  }
 
   EXPECT_FALSE(true) << "Unexpected message: " << request.ToString();
   return false;
@@ -153,8 +155,9 @@ CefRefPtr<CefDictionaryValue> ExtensionTestHandler::CreateDefaultManifest(
   CefRefPtr<CefListValue> permissions = CefListValue::Create();
   permissions->SetSize(api_permissions.size() + 2);
   size_t idx = 0;
-  for (; idx < api_permissions.size(); ++idx)
+  for (; idx < api_permissions.size(); ++idx) {
     permissions->SetString(idx, api_permissions[idx]);
+  }
 
   // Allow access to all http/https origins.
   permissions->SetString(idx++, "http://*/*");
diff --git a/tests/ceftests/extensions/view_unittest.cc b/tests/ceftests/extensions/view_unittest.cc
index 0e04e4471..4d9c03cb5 100644
--- a/tests/ceftests/extensions/view_unittest.cc
+++ b/tests/ceftests/extensions/view_unittest.cc
@@ -52,11 +52,13 @@ class ViewLoadUnloadTestHandler : public ExtensionTestHandler {
     EXPECT_TRUE(extension_->IsSame(extension));
 
     // The extension should no longer be registered with the context.
-    if (loader_request_context())
+    if (loader_request_context()) {
       VerifyExtensionInContext(extension, loader_request_context(), false,
                                true);
-    if (request_context() && !request_context_same_loader())
+    }
+    if (request_context() && !request_context_same_loader()) {
       VerifyExtensionInContext(extension, request_context(), false, false);
+    }
 
     extension_ = nullptr;
 
@@ -164,8 +166,9 @@ class ViewLoadUnloadTestHandler : public ExtensionTestHandler {
     TestDictionaryEqual(expected_manifest, extension->GetManifest());
 
     VerifyExtensionInContext(extension, loader_request_context(), true, true);
-    if (!request_context_same_loader())
+    if (!request_context_same_loader()) {
       VerifyExtensionInContext(extension, request_context(), true, false);
+    }
   }
 
   void CreateBrowserForExtension() {
diff --git a/tests/ceftests/frame_handler_unittest.cc b/tests/ceftests/frame_handler_unittest.cc
index 45abe1d78..ac9a33930 100644
--- a/tests/ceftests/frame_handler_unittest.cc
+++ b/tests/ceftests/frame_handler_unittest.cc
@@ -132,8 +132,9 @@ struct FrameStatus {
       ss << ident_str_ << "(";
       for (int i = 0; i <= LOAD_END; ++i) {
         ss << GetCallbackName(i) << "=" << got_callback_[i];
-        if (i < LOAD_END)
+        if (i < LOAD_END) {
           ss << " ";
+        }
       }
       ss << ")";
       *msg += ss.str();
@@ -316,8 +317,9 @@ struct FrameStatus {
     EXPECT_GE(pending_queries_.size(), 1U);
     const std::string& expected_query = pending_queries_.front();
     EXPECT_STREQ(expected_query.c_str(), received_query.c_str());
-    if (expected_query == received_query)
+    if (expected_query == received_query) {
       pending_queries_.pop();
+    }
 
     EXPECT_LT(delivered_query_ct_, expected_query_ct_);
     delivered_query_ct_++;
@@ -359,8 +361,9 @@ struct FrameStatus {
   }
 
   bool IsExpectedCallback(int callback) const {
-    if (!is_main_ && IsMainFrameOnlyCallback(callback))
+    if (!is_main_ && IsMainFrameOnlyCallback(callback)) {
       return false;
+    }
 
     if (is_main_) {
       if ((callback == MAIN_FRAME_INITIAL_ASSIGNED ||
@@ -478,8 +481,9 @@ struct FrameStatus {
     EXPECT_TRUE(got_callback_[callback]) << GetCallbackName(callback);
     got_callback_[callback].reset();
 
-    if (expect_query)
+    if (expect_query) {
       delivered_query_ct_--;
+    }
   }
 
   const int64 frame_id_;
@@ -697,15 +701,17 @@ class OrderMainTestHandler : public RoutingTestHandler, public CefFrameHandler {
 
   virtual bool AllQueriesDelivered(std::string* msg = nullptr) const {
     EXPECT_UI_THREAD();
-    if (pending_main_frame_)
+    if (pending_main_frame_) {
       return false;
+    }
     return current_main_frame_->AllQueriesDelivered(msg);
   }
 
   virtual bool AllFramesLoaded(std::string* msg = nullptr) const {
     EXPECT_UI_THREAD();
-    if (pending_main_frame_)
+    if (pending_main_frame_) {
       return false;
+    }
     return current_main_frame_->IsLoaded(msg);
   }
 
@@ -984,13 +990,15 @@ class FrameStatusMap {
   }
 
   bool AllFramesDetached() const {
-    if (size() != expected_frame_ct_)
+    if (size() != expected_frame_ct_) {
       return false;
+    }
 
     Map::const_iterator it = frame_map_.begin();
     for (; it != frame_map_.end(); ++it) {
-      if (!it->second->IsDetached())
+      if (!it->second->IsDetached()) {
         return false;
+      }
     }
 
     return true;
@@ -1181,24 +1189,27 @@ class OrderSubTestHandler : public NavigateOrderMainTestHandler {
   bool AllQueriesDelivered(std::string* msg = nullptr) const override {
     if (!NavigateOrderMainTestHandler::AllQueriesDelivered(msg)) {
 #if VERBOSE_DEBUGGING
-      if (msg)
+      if (msg) {
         *msg += " MAIN PENDING";
+      }
 #endif
       return false;
     }
 
     if (frame_maps_.empty()) {
 #if VERBOSE_DEBUGGING
-      if (msg)
+      if (msg) {
         *msg += " NO SUBS";
+      }
 #endif
       return false;
     }
 
     if (!frame_maps_.back()->AllQueriesDelivered(msg)) {
 #if VERBOSE_DEBUGGING
-      if (msg)
+      if (msg) {
         *msg += " SUBS PENDING";
+      }
 #endif
       return false;
     }
@@ -1208,24 +1219,27 @@ class OrderSubTestHandler : public NavigateOrderMainTestHandler {
   bool AllFramesLoaded(std::string* msg = nullptr) const override {
     if (!NavigateOrderMainTestHandler::AllFramesLoaded(msg)) {
 #if VERBOSE_DEBUGGING
-      if (msg)
+      if (msg) {
         *msg += " MAIN PENDING";
+      }
 #endif
       return false;
     }
 
     if (frame_maps_.empty()) {
 #if VERBOSE_DEBUGGING
-      if (msg)
+      if (msg) {
         *msg += " NO SUBS";
+      }
 #endif
       return false;
     }
 
     if (!frame_maps_.back()->AllFramesLoaded(msg)) {
 #if VERBOSE_DEBUGGING
-      if (msg)
+      if (msg) {
         *msg += " SUBS PENDING";
+      }
 #endif
       return false;
     }
@@ -1241,8 +1255,9 @@ class OrderSubTestHandler : public NavigateOrderMainTestHandler {
 
   FrameStatusMap* GetFrameMap(CefRefPtr<CefFrame> frame) const {
     for (auto& map : frame_maps_) {
-      if (map->Contains(frame))
+      if (map->Contains(frame)) {
         return map.get();
+      }
     }
     return nullptr;
   }
@@ -1266,8 +1281,9 @@ class OrderSubTestHandler : public NavigateOrderMainTestHandler {
   }
 
   FrameStatusMap* GetOrCreateFrameMap(CefRefPtr<CefFrame> frame) {
-    if (auto map = GetFrameMap(frame))
+    if (auto map = GetFrameMap(frame)) {
       return map;
+    }
 
     if (frame_maps_.empty() ||
         frame_maps_.back()->size() >= expected_frame_ct_) {
diff --git a/tests/ceftests/frame_unittest.cc b/tests/ceftests/frame_unittest.cc
index a9abd0370..b1650aefd 100644
--- a/tests/ceftests/frame_unittest.cc
+++ b/tests/ceftests/frame_unittest.cc
@@ -277,22 +277,25 @@ class FrameNavRendererTest : public ClientAppRenderer::Delegate,
   void OnBrowserCreated(CefRefPtr<ClientAppRenderer> app,
                         CefRefPtr<CefBrowser> browser,
                         CefRefPtr<CefDictionaryValue> extra_info) override {
-    if (!extra_info || !extra_info->HasKey(kFrameNavTestCmdKey))
+    if (!extra_info || !extra_info->HasKey(kFrameNavTestCmdKey)) {
       return;
+    }
 
     FrameNavFactoryId factory_id =
         static_cast<FrameNavFactoryId>(extra_info->GetInt(kFrameNavTestCmdKey));
     run_test_ = factory_id != FNF_ID_INVALID;
-    if (!run_test_)
+    if (!run_test_) {
       return;
+    }
 
     factory_ = FrameNavExpectationsFactoryRenderer::FromID(factory_id);
   }
 
   CefRefPtr<CefLoadHandler> GetLoadHandler(
       CefRefPtr<ClientAppRenderer> app) override {
-    if (!run_test_)
+    if (!run_test_) {
       return nullptr;
+    }
 
     return this;
   }
@@ -324,8 +327,9 @@ class FrameNavRendererTest : public ClientAppRenderer::Delegate,
   // Create a new expectations object if one does not already exist for the
   // current navigation.
   void CreateExpectationsIfNecessary() {
-    if (expectations_)
+    if (expectations_) {
       return;
+    }
     expectations_ = factory_->Create(
         nav_, base::BindOnce(&FrameNavRendererTest::SendTestResults, this));
   }
@@ -424,8 +428,9 @@ class FrameNavTestHandler : public TestHandler {
       CefRefPtr<CefFrame> frame,
       CefRefPtr<CefRequest> request) override {
     const std::string& url = request->GetURL();
-    if (IgnoreURL(url))
+    if (IgnoreURL(url)) {
       return nullptr;
+    }
 
     EXPECT_TRUE(expectations_->GetResourceHandler(browser, frame))
         << "nav = " << nav_;
@@ -497,8 +502,9 @@ class FrameNavTestHandler : public TestHandler {
   }
 
   void DestroyTest() override {
-    if (got_destroyed_)
+    if (got_destroyed_) {
       return;
+    }
 
     got_destroyed_.yes();
 
@@ -620,8 +626,9 @@ class FrameNavExpectationsBrowserSingleNav
  private:
   void SignalCompleteIfDone(CefRefPtr<CefBrowser> browser,
                             CefRefPtr<CefFrame> frame) {
-    if (got_renderer_done_ && got_load_end_ && got_loading_state_change_end_)
+    if (got_renderer_done_ && got_load_end_ && got_loading_state_change_end_) {
       SignalComplete(browser, frame);
+    }
   }
 
   TrackCallback got_load_start_;
@@ -690,8 +697,9 @@ class FrameNavExpectationsRendererSingleNav
  private:
   void SignalCompleteIfDone(CefRefPtr<CefBrowser> browser,
                             CefRefPtr<CefFrame> frame) {
-    if (got_load_end_ && got_loading_state_change_end_)
+    if (got_load_end_ && got_loading_state_change_end_) {
       SignalComplete(browser, frame);
+    }
   }
 
   TrackCallback got_load_start_;
@@ -1053,8 +1061,9 @@ class FrameNavExpectationsBrowserMultiNav : public FrameNavExpectationsBrowser {
 
   bool OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
                             bool isLoading) override {
-    if (!isLoading)
+    if (!isLoading) {
       SignalCompleteIfDone(browser, browser->GetMainFrame());
+    }
     return true;
   }
 
@@ -1085,8 +1094,9 @@ class FrameNavExpectationsBrowserMultiNav : public FrameNavExpectationsBrowser {
  private:
   void SignalCompleteIfDone(CefRefPtr<CefBrowser> browser,
                             CefRefPtr<CefFrame> frame) {
-    if (IsNavigationDone())
+    if (IsNavigationDone()) {
       SignalComplete(browser, frame);
+    }
   }
 
   TrackCallback got_finalize_;
@@ -1108,8 +1118,9 @@ class FrameNavExpectationsRendererMultiNav
 
   bool OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
                             bool isLoading) override {
-    if (!isLoading)
+    if (!isLoading) {
       SignalCompleteIfDone(browser, browser->GetMainFrame());
+    }
     return true;
   }
 
@@ -1131,8 +1142,9 @@ class FrameNavExpectationsRendererMultiNav
  private:
   void SignalCompleteIfDone(CefRefPtr<CefBrowser> browser,
                             CefRefPtr<CefFrame> frame) {
-    if (IsNavigationDone())
+    if (IsNavigationDone()) {
       SignalComplete(browser, frame);
+    }
   }
 
   TrackCallback got_finalize_;
@@ -1393,8 +1405,9 @@ class FrameNavExpectationsBrowserTestMultiNav
 
   bool OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
                             bool isLoading) override {
-    if (!isLoading)
+    if (!isLoading) {
       got_load_state_change_done_.yes();
+    }
     V_DECLARE();
     if (isLoading && nav() == 0) {
       V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, nullptr, std::string()));
@@ -1438,8 +1451,9 @@ class FrameNavExpectationsBrowserTestMultiNav
                       const std::string& url) override {
     V_DECLARE();
     std::string expected_url;
-    if (nav() > 0)
+    if (nav() > 0) {
       expected_url = GetPreviousMainURL();
+    }
     V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, frame, expected_url));
     V_EXPECT_TRUE(parent::OnBeforeBrowse(browser, frame, url));
     V_RETURN();
@@ -1449,8 +1463,9 @@ class FrameNavExpectationsBrowserTestMultiNav
                           CefRefPtr<CefFrame> frame) override {
     V_DECLARE();
     std::string expected_url;
-    if (nav() > 0)
+    if (nav() > 0) {
       expected_url = GetPreviousMainURL();
+    }
     V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, frame, expected_url));
     V_EXPECT_TRUE(parent::GetResourceHandler(browser, frame));
     V_RETURN();
@@ -1502,8 +1517,9 @@ class FrameNavExpectationsRendererTestMultiNav
 
   bool OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
                             bool isLoading) override {
-    if (!isLoading)
+    if (!isLoading) {
       got_load_state_change_done_.yes();
+    }
     V_DECLARE();
     V_EXPECT_TRUE(VerifySingleBrowserFrames(browser, nullptr, GetMainURL()));
     V_EXPECT_TRUE(parent::OnLoadingStateChange(browser, isLoading));
@@ -1627,8 +1643,9 @@ bool VerifyBrowserIframe(CefRefPtr<CefBrowser> browser,
     auto it = expected_names.find(nameStr);
     V_EXPECT_FALSE(it == expected_names.end())
         << "Unexpected name: \"" << nameStr << "\"";
-    if (it != expected_names.end())
+    if (it != expected_names.end()) {
       expected_names.erase(it);
+    }
   }
 
   for (const auto& name : expected_names) {
@@ -1744,8 +1761,9 @@ bool VerifyBrowserIframe(CefRefPtr<CefBrowser> browser,
   for (const auto& ident : idents) {
     auto it = expected_idents.find(ident);
     V_EXPECT_FALSE(it == expected_idents.end()) << "Unexpected id: " << ident;
-    if (it != expected_idents.end())
+    if (it != expected_idents.end()) {
       expected_idents.erase(it);
+    }
   }
 
   for (const auto& ident : expected_idents) {
@@ -1999,8 +2017,9 @@ class FrameNavExpectationsRendererTestNestedIframes
 
   FrameNavExpectationsRendererTestNestedIframes(int nav, bool same_origin)
       : parent(nav) {
-    if (same_origin)
+    if (same_origin) {
       origin_ = kFrameNavOrigin0;
+    }
   }
 
   bool IsNavigationDone() const override {
diff --git a/tests/ceftests/image_unittest.cc b/tests/ceftests/image_unittest.cc
index dba6a7c1e..f41da5e55 100644
--- a/tests/ceftests/image_unittest.cc
+++ b/tests/ceftests/image_unittest.cc
@@ -38,10 +38,11 @@ void VerifyScaleExists(CefRefPtr<CefImage> image,
   int expected_pixel_size = kExpectedDIPSize * expected_scale_factor;
 
   // Only returns true for exact matches.
-  if (scale_factor == expected_scale_factor)
+  if (scale_factor == expected_scale_factor) {
     EXPECT_TRUE(image->HasRepresentation(scale_factor));
-  else
+  } else {
     EXPECT_FALSE(image->HasRepresentation(scale_factor));
+  }
 
   // Returns the closest match.
   EXPECT_TRUE(image->GetRepresentationInfo(scale_factor, actual_scale_factor,
diff --git a/tests/ceftests/image_util.cc b/tests/ceftests/image_util.cc
index 29b7618ed..c31d9056b 100644
--- a/tests/ceftests/image_util.cc
+++ b/tests/ceftests/image_util.cc
@@ -16,10 +16,11 @@ void LoadImage(CefRefPtr<CefImage> image,
   std::string image_str;
 
   std::string name_str;
-  if (scale_factor == 1.0f)
+  if (scale_factor == 1.0f) {
     name_str = name + ".1x.png";
-  else if (scale_factor == 2.0f)
+  } else if (scale_factor == 2.0f) {
     name_str = name + ".2x.png";
+  }
 
   EXPECT_TRUE(client::LoadBinaryResource(name_str.c_str(), image_str));
   EXPECT_TRUE(image->AddPNG(scale_factor, image_str.c_str(), image_str.size()));
diff --git a/tests/ceftests/jsdialog_unittest.cc b/tests/ceftests/jsdialog_unittest.cc
index d6ddcf8a9..4f75e84bd 100644
--- a/tests/ceftests/jsdialog_unittest.cc
+++ b/tests/ceftests/jsdialog_unittest.cc
@@ -75,8 +75,9 @@ class JSDialogTestHandler : public TestHandler {
   void OnLoadEnd(CefRefPtr<CefBrowser> browser,
                  CefRefPtr<CefFrame> frame,
                  int httpStatusCode) override {
-    if (!frame->IsMain())
+    if (!frame->IsMain()) {
       return;
+    }
 
     std::string url = frame->GetURL();
     if (url.find(kEndUrl) == 0) {
diff --git a/tests/ceftests/life_span_unittest.cc b/tests/ceftests/life_span_unittest.cc
index 7c1f95b3a..262bb7a5a 100644
--- a/tests/ceftests/life_span_unittest.cc
+++ b/tests/ceftests/life_span_unittest.cc
@@ -63,8 +63,9 @@ class LifeSpanTestHandler : public RoutingTestHandler {
   }
 
   bool DoClose(CefRefPtr<CefBrowser> browser) override {
-    if (executing_delay_close_)
+    if (executing_delay_close_) {
       return false;
+    }
 
     EXPECT_TRUE(browser->IsSame(GetBrowser()));
 
@@ -139,8 +140,9 @@ class LifeSpanTestHandler : public RoutingTestHandler {
                bool persistent,
                CefRefPtr<Callback> callback) override {
     if (request.ToString() == kUnloadMsg) {
-      if (!executing_delay_close_)
+      if (!executing_delay_close_) {
         got_unload_message_.yes();
+      }
     }
     callback->Success("");
     return true;
diff --git a/tests/ceftests/message_router_multi_query_unittest.cc b/tests/ceftests/message_router_multi_query_unittest.cc
index 48bb42848..7e79db111 100644
--- a/tests/ceftests/message_router_multi_query_unittest.cc
+++ b/tests/ceftests/message_router_multi_query_unittest.cc
@@ -102,8 +102,9 @@ class MultiQueryManager : public CefMessageRouterBrowserSide::Handler {
   void AddTestQuery(TestType type) {
     EXPECT_FALSE(finalized_);
     test_query_vector_.push_back(TestQuery(type));
-    if (!IsAuto(type))
+    if (!IsAuto(type)) {
       manual_total_++;
+    }
   }
 
   // Must be called after AddTestQuery and before the manager is used.
@@ -128,10 +129,12 @@ class MultiQueryManager : public CefMessageRouterBrowserSide::Handler {
     html = "<html><body>" + label_ + "<script>\n";
 
     // No requests should exist.
-    if (assert_total)
+    if (assert_total) {
       html += "window.mrtAssertTotalCount(" LINESTR ",0);\n";
-    if (assert_browser)
+    }
+    if (assert_browser) {
       html += "window.mrtAssertBrowserCount(" LINESTR ",0);\n";
+    }
     html += "window.mrtAssertContextCount(" LINESTR ",0);\n";
 
     if (synchronous_) {
@@ -146,11 +149,13 @@ class MultiQueryManager : public CefMessageRouterBrowserSide::Handler {
 
       // Pending requests should match the total created.
       const std::string& total_val = GetIntString(total_ct);
-      if (assert_total)
+      if (assert_total) {
         html += "window.mrtAssertTotalCount(" LINESTR "," + total_val + ");\n";
-      if (assert_browser)
+      }
+      if (assert_browser) {
         html +=
             "window.mrtAssertBrowserCount(" LINESTR "," + total_val + ");\n";
+      }
       html += "window.mrtAssertContextCount(" LINESTR "," + total_val + ");\n";
 
       int cancel_ct = 0;
@@ -167,12 +172,14 @@ class MultiQueryManager : public CefMessageRouterBrowserSide::Handler {
       if (cancel_ct > 0) {
         // Pending requests should match the total not canceled.
         const std::string& cancel_val = GetIntString(total_ct - cancel_ct);
-        if (assert_total)
+        if (assert_total) {
           html +=
               "window.mrtAssertTotalCount(" LINESTR "," + cancel_val + ");\n";
-        if (assert_browser)
+        }
+        if (assert_browser) {
           html +=
               "window.mrtAssertBrowserCount(" LINESTR "," + cancel_val + ");\n";
+        }
         html +=
             "window.mrtAssertContextCount(" LINESTR "," + cancel_val + ");\n";
       }
@@ -217,8 +224,9 @@ class MultiQueryManager : public CefMessageRouterBrowserSide::Handler {
     EXPECT_TRUE(finalized_);
     EXPECT_UI_THREAD();
 
-    if (!running_)
+    if (!running_) {
       running_ = true;
+    }
 
     EXPECT_TRUE(browser.get());
     EXPECT_TRUE(frame.get());
@@ -240,17 +248,19 @@ class MultiQueryManager : public CefMessageRouterBrowserSide::Handler {
       EXPECT_STREQ(kMultiQueryError, value.c_str()) << index;
       EXPECT_TRUE(IsAuto(query.type)) << index;
       EXPECT_TRUE(query.got_query) << index;
-      if (query.type == PERSISTENT_AUTOCANCEL)
+      if (query.type == PERSISTENT_AUTOCANCEL) {
         EXPECT_TRUE(query.got_success) << index;
-      else
+      } else {
         EXPECT_FALSE(query.got_success) << index;
+      }
 
       query.got_error.yes();
 
       // There's a race between OnQueryCanceled and OnNotification. Only call
       // OnQueryCompleted a single time.
-      if (query.got_query_canceled)
+      if (query.got_query_canceled) {
         OnQueryCompleted(query.type);
+      }
     } else {
       EXPECT_STREQ(kMultiQuerySuccess, value.c_str()) << index;
       EXPECT_TRUE(WillNotify(query.type)) << index;
@@ -261,12 +271,14 @@ class MultiQueryManager : public CefMessageRouterBrowserSide::Handler {
       query.got_success.yes();
 
       // PERSISTENT_AUTOCANCEL doesn't call OnReceiveCompleted from OnQuery.
-      if (query.type == PERSISTENT_AUTOCANCEL)
+      if (query.type == PERSISTENT_AUTOCANCEL) {
         OnReceiveCompleted(query.type);
+      }
 
       // Call OnQueryCompleted for types that don't get OnQueryCanceled.
-      if (!WillCancel(query.type))
+      if (!WillCancel(query.type)) {
         OnQueryCompleted(query.type);
+      }
     }
   }
 
@@ -279,8 +291,9 @@ class MultiQueryManager : public CefMessageRouterBrowserSide::Handler {
     EXPECT_TRUE(finalized_);
     EXPECT_UI_THREAD();
 
-    if (!running_)
+    if (!running_) {
       running_ = true;
+    }
 
     EXPECT_TRUE(browser.get());
     EXPECT_TRUE(frame.get());
@@ -292,10 +305,11 @@ class MultiQueryManager : public CefMessageRouterBrowserSide::Handler {
 
     TestQuery& query = test_query_vector_[index];
 
-    if (IsPersistent(query.type))
+    if (IsPersistent(query.type)) {
       EXPECT_TRUE(persistent);
-    else
+    } else {
       EXPECT_FALSE(persistent);
+    }
 
     // Verify expected request.
     EXPECT_STREQ(kMultiQueryRequest, value.c_str()) << index;
@@ -318,8 +332,9 @@ class MultiQueryManager : public CefMessageRouterBrowserSide::Handler {
     } else if (IsPersistent(query.type)) {
       // Send the required number of successful responses.
       const std::string& response = GetIDString(kMultiQueryResponse, index);
-      for (int i = 0; i < kMultiQueryPersistentResponseCount; ++i)
+      for (int i = 0; i < kMultiQueryPersistentResponseCount; ++i) {
         callback->Success(response);
+      }
     }
 
     if (WillFail(query.type)) {
@@ -335,8 +350,9 @@ class MultiQueryManager : public CefMessageRouterBrowserSide::Handler {
 
     // PERSISTENT_AUTOCANCEL will call OnReceiveCompleted once the success
     // notification is received.
-    if (query.type != PERSISTENT_AUTOCANCEL)
+    if (query.type != PERSISTENT_AUTOCANCEL) {
       OnReceiveCompleted(query.type);
+    }
 
     return true;
   }
@@ -347,8 +363,9 @@ class MultiQueryManager : public CefMessageRouterBrowserSide::Handler {
     EXPECT_TRUE(finalized_);
     EXPECT_UI_THREAD();
 
-    if (!running_)
+    if (!running_) {
       running_ = true;
+    }
 
     EXPECT_TRUE(browser.get());
     EXPECT_TRUE(frame.get());
@@ -390,8 +407,9 @@ class MultiQueryManager : public CefMessageRouterBrowserSide::Handler {
         if (will_cancel_by_removing_handler_) {
           // There's a race between OnQueryCanceled and OnNotification. Only
           // call OnQueryCompleted a single time.
-          if (query.got_error)
+          if (query.got_error) {
             OnQueryCompleted(query.type);
+          }
         } else {
           EXPECT_FALSE(query.got_error) << i;
 
@@ -416,20 +434,23 @@ class MultiQueryManager : public CefMessageRouterBrowserSide::Handler {
       const TestQuery& query = test_query_vector_[i];
       EXPECT_TRUE(query.got_query) << i;
 
-      if (WillCancel(query.type))
+      if (WillCancel(query.type)) {
         EXPECT_TRUE(query.got_query_canceled) << i;
-      else
+      } else {
         EXPECT_FALSE(query.got_query_canceled) << i;
+      }
 
-      if (WillNotify(query.type))
+      if (WillNotify(query.type)) {
         EXPECT_TRUE(query.got_success) << i;
-      else
+      } else {
         EXPECT_FALSE(query.got_success) << i;
+      }
 
-      if (IsAuto(query.type) && will_cancel_by_removing_handler_)
+      if (IsAuto(query.type) && will_cancel_by_removing_handler_) {
         EXPECT_TRUE(query.got_error);
-      else
+      } else {
         EXPECT_FALSE(query.got_error);
+      }
 
       EXPECT_FALSE(query.callback.get()) << i;
     }
@@ -489,10 +510,11 @@ class MultiQueryManager : public CefMessageRouterBrowserSide::Handler {
 
     void Execute() override {
       if (weak_ptr_) {
-        if (notify_all_)
+        if (notify_all_) {
           weak_ptr_->NotifyAllQueriesCompleted();
-        else
+        } else {
           weak_ptr_->NotifyManualQueriesCompleted();
+        }
       }
     }
 
@@ -541,9 +563,9 @@ class MultiQueryManager : public CefMessageRouterBrowserSide::Handler {
     EXPECT_LE(manual_complete_count_, manual_total_);
 
     const bool is_auto = IsAuto(type);
-    if (is_auto)
+    if (is_auto) {
       auto_complete_count_++;
-    else if (++manual_complete_count_ == manual_total_) {
+    } else if (++manual_complete_count_ == manual_total_) {
       CefPostTask(TID_UI,
                   new NotifyTask(weak_ptr_factory_.GetWeakPtr(), false));
     }
@@ -555,8 +577,9 @@ class MultiQueryManager : public CefMessageRouterBrowserSide::Handler {
   }
 
   void NotifyManualQueriesCompleted() {
-    if (observer_set_.empty())
+    if (observer_set_.empty()) {
       return;
+    }
 
     // Use a copy of the set in case an Observer is removed while we're
     // iterating.
@@ -569,8 +592,9 @@ class MultiQueryManager : public CefMessageRouterBrowserSide::Handler {
   }
 
   void NotifyAllQueriesCompleted() {
-    if (observer_set_.empty())
+    if (observer_set_.empty()) {
       return;
+    }
 
     // Use a copy of the set in case an Observer is removed while we're
     // iterating.
@@ -597,8 +621,9 @@ class MultiQueryManager : public CefMessageRouterBrowserSide::Handler {
 
     const bool persistent = IsPersistent(query.type);
 
-    if (persistent)
+    if (persistent) {
       html += "var " + repeat_ct_var + " = 0;\n";
+    }
 
     html += "var " + request_id_var +
             " = window.mrtQuery({\n"
@@ -1093,8 +1118,9 @@ class MultiQueryMultiHandlerTestHandler : public SingleLoadTestHandler,
       std::stringstream ss;
       ss << kMultiQueryRequest << ":" << index_;
       const std::string& handled_request = ss.str();
-      if (request != handled_request)
+      if (request != handled_request) {
         return false;
+      }
 
       // Verify that handlers are called in the correct order.
       if (index_ == 0) {
@@ -1377,8 +1403,9 @@ class MultiQueryManagerMap : public CefMessageRouterBrowserSide::Handler,
                 CefRefPtr<CefFrame> frame,
                 const std::string& message) {
     EXPECT_TRUE(finalized_);
-    if (!running_)
+    if (!running_) {
       running_ = true;
+    }
 
     MultiQueryManager* manager = GetManager(browser, frame);
     manager->OnNotify(browser, frame, message);
@@ -1391,8 +1418,9 @@ class MultiQueryManagerMap : public CefMessageRouterBrowserSide::Handler,
                bool persistent,
                CefRefPtr<Callback> callback) override {
     EXPECT_TRUE(finalized_);
-    if (!running_)
+    if (!running_) {
       running_ = true;
+    }
 
     MultiQueryManager* manager = GetManager(browser, frame);
     return manager->OnQuery(browser, frame, query_id, request, persistent,
@@ -1403,8 +1431,9 @@ class MultiQueryManagerMap : public CefMessageRouterBrowserSide::Handler,
                        CefRefPtr<CefFrame> frame,
                        int64 query_id) override {
     EXPECT_TRUE(finalized_);
-    if (!running_)
+    if (!running_) {
       running_ = true;
+    }
 
     MultiQueryManager* manager = GetManager(browser, frame);
     manager->OnQueryCanceled(browser, frame, query_id);
@@ -1454,8 +1483,9 @@ class MultiQueryManagerMap : public CefMessageRouterBrowserSide::Handler,
     EXPECT_TRUE(finalized_);
 
     for (size_t i = 0; i < all_managers_.size(); ++i) {
-      if (!all_managers_[i]->IsAllComplete())
+      if (!all_managers_[i]->IsAllComplete()) {
         return false;
+      }
     }
     return true;
   }
@@ -1472,16 +1502,18 @@ class MultiQueryManagerMap : public CefMessageRouterBrowserSide::Handler,
 
   bool HasAutoQueries() const {
     for (size_t i = 0; i < all_managers_.size(); ++i) {
-      if (all_managers_[i]->HasAutoQueries())
+      if (all_managers_[i]->HasAutoQueries()) {
         return true;
+      }
     }
 
     return false;
   }
 
   void OnLoadStart(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame) {
-    if (pending_managers_.empty())
+    if (pending_managers_.empty()) {
       return;
+    }
 
     const std::string& expected_url = frame->GetURL();
     MultiQueryManager* next_manager = nullptr;
@@ -1506,8 +1538,9 @@ class MultiQueryManagerMap : public CefMessageRouterBrowserSide::Handler,
 
     // Remove the currently active manager, if any.
     ManagerMap::iterator it2 = manager_map_.find(id);
-    if (it2 != manager_map_.end())
+    if (it2 != manager_map_.end()) {
       manager_map_.erase(it2);
+    }
 
     // Add the next manager to the active map.
     manager_map_.insert(std::make_pair(id, next_manager));
@@ -1529,8 +1562,9 @@ class MultiQueryManagerMap : public CefMessageRouterBrowserSide::Handler,
 
   void RemoveAllManagers() {
     EXPECT_TRUE(pending_managers_.empty());
-    if (all_managers_.empty())
+    if (all_managers_.empty()) {
       return;
+    }
 
     for (size_t i = 0; i < all_managers_.size(); ++i) {
       delete all_managers_[i];
@@ -1599,8 +1633,9 @@ class MultiQueryMultiFrameTestHandler : public SingleLoadTestHandler,
                    CefRefPtr<CefFrame> frame,
                    TransitionType transition_type) override {
     AssertMainBrowser(browser);
-    if (!frame->IsMain())
+    if (!frame->IsMain()) {
       manager_map_.OnLoadStart(browser, frame);
+    }
   }
 
   void OnNotify(CefRefPtr<CefBrowser> browser,
@@ -1907,10 +1942,11 @@ class MultiQueryMultiNavigateTestHandler
 
   void OnManualQueriesCompleted(MultiQueryManager* manager) override {
     const std::string& url = manager->label();
-    if (url == url1_)  // 2. Load the 2nd url.
+    if (url == url1_) {  // 2. Load the 2nd url.
       GetBrowser()->GetMainFrame()->LoadURL(url2_);
-    else if (url == url2_)  // 3. Load the 3rd url.
+    } else if (url == url2_) {  // 3. Load the 3rd url.
       GetBrowser()->GetMainFrame()->LoadURL(url3_);
+    }
   }
 
  protected:
diff --git a/tests/ceftests/message_router_single_query_unittest.cc b/tests/ceftests/message_router_single_query_unittest.cc
index ed00ac85e..bb5373a0b 100644
--- a/tests/ceftests/message_router_single_query_unittest.cc
+++ b/tests/ceftests/message_router_single_query_unittest.cc
@@ -182,12 +182,14 @@ class SingleQueryTestHandler : public SingleLoadTestHandler {
 
   void DestroyTestIfDone() {
     bool destroy_test = false;
-    if (test_type_ == CANCEL)
+    if (test_type_ == CANCEL) {
       destroy_test = got_notify_ && got_on_query_canceled_;
-    else
+    } else {
       destroy_test = got_notify_;
-    if (destroy_test)
+    }
+    if (destroy_test) {
       DestroyTest();
+    }
   }
 
   void DestroyTest() override {
@@ -195,10 +197,11 @@ class SingleQueryTestHandler : public SingleLoadTestHandler {
     EXPECT_TRUE(got_on_query_);
     EXPECT_FALSE(callback_.get());
 
-    if (test_type_ == CANCEL)
+    if (test_type_ == CANCEL) {
       EXPECT_TRUE(got_on_query_canceled_);
-    else
+    } else {
       EXPECT_FALSE(got_on_query_canceled_);
+    }
 
     TestHandler::DestroyTest();
   }
@@ -435,14 +438,16 @@ class SinglePersistentQueryTestHandler : public SingleLoadTestHandler {
   void DestroyTestIfDone() {
     bool destroy_test = false;
     if (test_type_ == SUCCESS) {
-      if (got_on_query_ && got_on_query_canceled_ && got_notify_)
+      if (got_on_query_ && got_on_query_canceled_ && got_notify_) {
         destroy_test = true;
+      }
     } else if (got_on_query_ && got_notify_) {
       destroy_test = true;
     }
 
-    if (destroy_test)
+    if (destroy_test) {
       DestroyTest();
+    }
   }
 
   void DestroyTest() override {
@@ -450,10 +455,11 @@ class SinglePersistentQueryTestHandler : public SingleLoadTestHandler {
     EXPECT_TRUE(got_on_query_);
     EXPECT_FALSE(callback_.get());
 
-    if (test_type_ == SUCCESS)
+    if (test_type_ == SUCCESS) {
       EXPECT_TRUE(got_on_query_canceled_);
-    else
+    } else {
       EXPECT_FALSE(got_on_query_canceled_);
+    }
 
     TestHandler::DestroyTest();
   }
diff --git a/tests/ceftests/message_router_unittest_utils.cc b/tests/ceftests/message_router_unittest_utils.cc
index b6dddf507..29800f1ae 100644
--- a/tests/ceftests/message_router_unittest_utils.cc
+++ b/tests/ceftests/message_router_unittest_utils.cc
@@ -96,8 +96,9 @@ void MRRenderDelegate::OnContextCreated(CefRefPtr<ClientAppRenderer> app,
                                         CefRefPtr<CefFrame> frame,
                                         CefRefPtr<CefV8Context> context) {
   const std::string& url = frame->GetURL();
-  if (url.find(kTestDomainRoot) != 0)
+  if (url.find(kTestDomainRoot) != 0) {
     return;
+  }
 
   message_router_->OnContextCreated(browser, frame, context);
 
@@ -132,8 +133,9 @@ void MRRenderDelegate::OnContextReleased(CefRefPtr<ClientAppRenderer> app,
                                          CefRefPtr<CefFrame> frame,
                                          CefRefPtr<CefV8Context> context) {
   const std::string& url = frame->GetURL();
-  if (url.find(kTestDomainRoot) != 0)
+  if (url.find(kTestDomainRoot) != 0) {
     return;
+  }
 
   message_router_->OnContextReleased(browser, frame, context);
 }
@@ -145,8 +147,9 @@ bool MRRenderDelegate::OnProcessMessageReceived(
     CefProcessId source_process,
     CefRefPtr<CefProcessMessage> message) {
   const std::string& url = frame->GetURL();
-  if (url.find(kTestDomainRoot) != 0)
+  if (url.find(kTestDomainRoot) != 0) {
     return false;
+  }
 
   return message_router_->OnProcessMessageReceived(browser, frame,
                                                    source_process, message);
@@ -165,8 +168,9 @@ void MRTestHandler::OnAfterCreated(CefRefPtr<CefBrowser> browser) {
     CefMessageRouterConfig config;
 
     SetRouterConfig(config);
-    if (message_size_threshold_)
+    if (message_size_threshold_) {
       config.message_size_threshold = message_size_threshold_;
+    }
 
     message_router_ = CefMessageRouterBrowserSide::Create(config);
     AddHandlers(message_router_);
diff --git a/tests/ceftests/navigation_unittest.cc b/tests/ceftests/navigation_unittest.cc
index edcb283e3..1fb1fa103 100644
--- a/tests/ceftests/navigation_unittest.cc
+++ b/tests/ceftests/navigation_unittest.cc
@@ -94,8 +94,9 @@ class HistoryNavRendererTest : public ClientAppRenderer::Delegate,
 
   CefRefPtr<CefLoadHandler> GetLoadHandler(
       CefRefPtr<ClientAppRenderer> app) override {
-    if (!run_test_)
+    if (!run_test_) {
       return nullptr;
+    }
 
     return this;
   }
@@ -177,8 +178,9 @@ class HistoryNavRendererTest : public ClientAppRenderer::Delegate,
  protected:
   void SendTestResultsIfDone(CefRefPtr<CefBrowser> browser,
                              CefRefPtr<CefFrame> frame) {
-    if (got_load_end_ && got_loading_state_end_)
+    if (got_load_end_ && got_loading_state_end_) {
       SendTestResults(browser, frame);
+    }
   }
 
   // Send the test results.
@@ -290,10 +292,11 @@ class NavigationEntryVisitor : public CefNavigationEntryVisitor {
     EXPECT_STREQ(expected_title.c_str(), entry->GetTitle().ToString().c_str());
 
     const auto transition_type = entry->GetTransitionType();
-    if (expected_forwardback_[index])
+    if (expected_forwardback_[index]) {
       EXPECT_EQ(kTransitionExplicitForwardBack, transition_type);
-    else
+    } else {
       EXPECT_EQ(kTransitionExplicitLoad, transition_type);
+    }
 
     EXPECT_FALSE(entry->HasPostData());
     EXPECT_GT(CefTimeFrom(entry->GetCompletionTime()).GetTimeT(), 0);
@@ -459,8 +462,9 @@ class HistoryNavTestHandler : public TestHandler {
     EXPECT_FALSE(got_before_resource_load_[nav_]);
     got_before_resource_load_[nav_].yes();
 
-    if (url == item.target)
+    if (url == item.target) {
       got_correct_target_[nav_].yes();
+    }
 
     return RV_CONTINUE;
   }
@@ -485,10 +489,12 @@ class HistoryNavTestHandler : public TestHandler {
     EXPECT_FALSE(got_loading_state_change_loaded_[nav_]);
     got_loading_state_change_loaded_[nav_].yes();
 
-    if (item.can_go_back == canGoBack)
+    if (item.can_go_back == canGoBack) {
       got_correct_can_go_back_[nav_].yes();
-    if (item.can_go_forward == canGoForward)
+    }
+    if (item.can_go_forward == canGoForward) {
       got_correct_can_go_forward_[nav_].yes();
+    }
 
     load_state_change_loaded_confirmation_ = true;
     RunNextNavIfReady(browser);
@@ -497,8 +503,9 @@ class HistoryNavTestHandler : public TestHandler {
   void OnLoadStart(CefRefPtr<CefBrowser> browser,
                    CefRefPtr<CefFrame> frame,
                    TransitionType transition_type) override {
-    if (browser->IsPopup() || !frame->IsMain())
+    if (browser->IsPopup() || !frame->IsMain()) {
       return;
+    }
 
     const NavListItem& item = kHNavList[nav_];
 
@@ -518,15 +525,17 @@ class HistoryNavTestHandler : public TestHandler {
 
     std::string url1 = browser->GetMainFrame()->GetURL();
     std::string url2 = frame->GetURL();
-    if (url1 == item.target && url2 == item.target)
+    if (url1 == item.target && url2 == item.target) {
       got_correct_load_start_url_[nav_].yes();
+    }
   }
 
   void OnLoadEnd(CefRefPtr<CefBrowser> browser,
                  CefRefPtr<CefFrame> frame,
                  int httpStatusCode) override {
-    if (browser->IsPopup() || !frame->IsMain())
+    if (browser->IsPopup() || !frame->IsMain()) {
       return;
+    }
 
     const NavListItem& item = kHNavList[nav_];
 
@@ -546,8 +555,9 @@ class HistoryNavTestHandler : public TestHandler {
 
     std::string url1 = browser->GetMainFrame()->GetURL();
     std::string url2 = frame->GetURL();
-    if (url1 == item.target && url2 == item.target)
+    if (url1 == item.target && url2 == item.target) {
       got_correct_load_end_url_[nav_].yes();
+    }
 
     load_end_confirmation_ = true;
     RunNextNavIfReady(browser);
@@ -718,16 +728,18 @@ class HistoryDynamicIFramesNavTestHandler : public TestHandler {
   void OnLoadStart(CefRefPtr<CefBrowser> browser,
                    CefRefPtr<CefFrame> frame,
                    TransitionType transition_type) override {
-    if (!frame->IsMain())
+    if (!frame->IsMain()) {
       return;
+    }
     got_load_start_[nav_].yes();
   }
 
   void OnLoadEnd(CefRefPtr<CefBrowser> browser,
                  CefRefPtr<CefFrame> frame,
                  int httpStatusCode) override {
-    if (!frame->IsMain())
+    if (!frame->IsMain()) {
       return;
+    }
     CefString url = browser->GetMainFrame()->GetURL();
     got_load_end_[nav_].yes();
 
@@ -1222,8 +1234,9 @@ class OrderNavRendererTest : public ClientAppRenderer::Delegate,
                         CefRefPtr<CefBrowser> browser,
                         CefRefPtr<CefDictionaryValue> extra_info) override {
     run_test_ = extra_info && extra_info->HasKey(kOrderNavTestCmdKey);
-    if (!run_test_)
+    if (!run_test_) {
       return;
+    }
 
     EXPECT_TRUE(got_webkit_initialized_);
 
@@ -1250,8 +1263,9 @@ class OrderNavRendererTest : public ClientAppRenderer::Delegate,
 
   void OnBrowserDestroyed(CefRefPtr<ClientAppRenderer> app,
                           CefRefPtr<CefBrowser> browser) override {
-    if (!run_test_)
+    if (!run_test_) {
       return;
+    }
 
     EXPECT_TRUE(got_webkit_initialized_);
 
@@ -1282,8 +1296,9 @@ class OrderNavRendererTest : public ClientAppRenderer::Delegate,
 
   CefRefPtr<CefLoadHandler> GetLoadHandler(
       CefRefPtr<ClientAppRenderer> app) override {
-    if (!run_test_)
+    if (!run_test_) {
       return nullptr;
+    }
 
     return this;
   }
@@ -1308,8 +1323,9 @@ class OrderNavRendererTest : public ClientAppRenderer::Delegate,
                                        canGoForward);
     }
 
-    if (!isLoading)
+    if (!isLoading) {
       SendTestResultsIfDone(browser, browser->GetMainFrame());
+    }
   }
 
   void OnLoadStart(CefRefPtr<CefBrowser> browser,
@@ -1363,13 +1379,15 @@ class OrderNavRendererTest : public ClientAppRenderer::Delegate,
   void SendTestResultsIfDone(CefRefPtr<CefBrowser> browser,
                              CefRefPtr<CefFrame> frame) {
     bool done = false;
-    if (browser->IsPopup())
+    if (browser->IsPopup()) {
       done = state_popup_.IsDone();
-    else
+    } else {
       done = state_main_.IsDone();
+    }
 
-    if (done)
+    if (done) {
       SendTestResults(browser, frame, kOrderNavMsg);
+    }
   }
 
   // Send the test results.
@@ -1385,10 +1403,11 @@ class OrderNavRendererTest : public ClientAppRenderer::Delegate,
     CefRefPtr<CefListValue> args = return_msg->GetArgumentList();
     EXPECT_TRUE(args.get());
     EXPECT_TRUE(args->SetBool(0, result));
-    if (browser->IsPopup())
+    if (browser->IsPopup()) {
       EXPECT_TRUE(args->SetInt(1, browser_id_popup_));
-    else
+    } else {
       EXPECT_TRUE(args->SetInt(1, browser_id_main_));
+    }
     frame->SendProcessMessage(PID_BROWSER, return_msg);
   }
 
@@ -1440,16 +1459,19 @@ class OrderNavTestHandler : public TestHandler {
   }
 
   void ContinueIfReady(CefRefPtr<CefBrowser> browser) {
-    if (!got_message_)
+    if (!got_message_) {
       return;
+    }
 
     bool done = false;
-    if (browser->IsPopup())
+    if (browser->IsPopup()) {
       done = state_popup_.IsDone();
-    else
+    } else {
       done = state_main_.IsDone();
-    if (!done)
+    }
+    if (!done) {
       return;
+    }
 
     got_message_ = false;
 
@@ -1513,12 +1535,13 @@ class OrderNavTestHandler : public TestHandler {
     }
 
     std::string url = request->GetURL();
-    if (url == KONav1)
+    if (url == KONav1) {
       EXPECT_FALSE(browser->IsPopup());
-    else if (url == KONav2)
+    } else if (url == KONav2) {
       EXPECT_TRUE(browser->IsPopup());
-    else
+    } else {
       EXPECT_TRUE(false);  // not reached
+    }
 
     return false;
   }
@@ -1560,8 +1583,9 @@ class OrderNavTestHandler : public TestHandler {
                                        canGoForward);
     }
 
-    if (!isLoading)
+    if (!isLoading) {
       ContinueIfReady(browser);
+    }
   }
 
   void OnLoadStart(CefRefPtr<CefBrowser> browser,
@@ -1693,8 +1717,9 @@ class LoadNavRendererTest : public ClientAppRenderer::Delegate,
                         CefRefPtr<CefBrowser> browser,
                         CefRefPtr<CefDictionaryValue> extra_info) override {
     run_test_ = extra_info && extra_info->HasKey(kLoadNavTestCmdKey);
-    if (!run_test_)
+    if (!run_test_) {
       return;
+    }
 
     // We'll get multiple calls to OnBrowserCreated for same-site navigations
     // with same-site BFCache enabled.
@@ -1710,8 +1735,9 @@ class LoadNavRendererTest : public ClientAppRenderer::Delegate,
 
   void OnBrowserDestroyed(CefRefPtr<ClientAppRenderer> app,
                           CefRefPtr<CefBrowser> browser) override {
-    if (!run_test_)
+    if (!run_test_) {
       return;
+    }
 
     EXPECT_GT(load_ct_, 0);
     EXPECT_GT(browser_created_ct_, 0);
@@ -1720,8 +1746,9 @@ class LoadNavRendererTest : public ClientAppRenderer::Delegate,
 
   CefRefPtr<CefLoadHandler> GetLoadHandler(
       CefRefPtr<ClientAppRenderer> app) override {
-    if (!run_test_)
+    if (!run_test_) {
       return nullptr;
+    }
 
     return this;
   }
@@ -1795,8 +1822,9 @@ class LoadNavTestHandler : public TestHandler {
   void RunTest() override {
     const std::string& url2 = GetURL2();
     std::string link;
-    if (mode_ != LOAD)
+    if (mode_ != LOAD) {
       link = "<a href=\"" + url2 + "\">CLICK ME</a>";
+    }
 
     // Add the resources that we will navigate to/from.
     AddResource(kLoadNav1,
@@ -1815,8 +1843,9 @@ class LoadNavTestHandler : public TestHandler {
   }
 
   void ContinueIfReady(CefRefPtr<CefBrowser> browser) {
-    if (!got_message_ || !got_load_end_)
+    if (!got_message_ || !got_load_end_) {
       return;
+    }
 
     std::string url = browser->GetMainFrame()->GetURL();
     if (url == kLoadNav1) {
@@ -1942,10 +1971,11 @@ class LoadNavTestHandler : public TestHandler {
     // OnOpenURLFromTab should only be called for the file URL.
     EXPECT_STREQ(GetURL2().c_str(), target_url.ToString().c_str());
 
-    if (mode_ == LOAD)
+    if (mode_ == LOAD) {
       EXPECT_FALSE(user_gesture);
-    else
+    } else {
       EXPECT_TRUE(user_gesture);
+    }
 
     EXPECT_EQ(WOD_NEW_BACKGROUND_TAB, target_disposition);
 
@@ -2084,10 +2114,11 @@ class LoadNavTestHandler : public TestHandler {
       }
     }
 
-    if (ExpectOpenURL())
+    if (ExpectOpenURL()) {
       EXPECT_TRUE(got_open_url_from_tab_);
-    else
+    } else {
       EXPECT_FALSE(got_open_url_from_tab_);
+    }
 
     TestHandler::DestroyTest();
   }
@@ -2288,8 +2319,9 @@ class PopupSimultaneousTestHandler : public TestHandler {
                             bool isLoading,
                             bool canGoBack,
                             bool canGoForward) override {
-    if (isLoading)
+    if (isLoading) {
       return;
+    }
 
     if (browser->IsPopup()) {
       const std::string& url = browser->GetMainFrame()->GetURL();
@@ -2318,8 +2350,9 @@ class PopupSimultaneousTestHandler : public TestHandler {
 
           got_before_close_[i].yes();
 
-          if (++before_close_ct_ == kSimultPopupCount)
+          if (++before_close_ct_ == kSimultPopupCount) {
             DestroyTest();
+          }
           return;
         }
       }
@@ -2418,12 +2451,13 @@ class PopupJSWindowOpenTestHandler : public TestHandler {
 
     if (browser->IsPopup()) {
       after_created_ct_++;
-      if (!popup1_)
+      if (!popup1_) {
         popup1_ = browser;
-      else if (!popup2_)
+      } else if (!popup2_) {
         popup2_ = browser;
-      else
+      } else {
         ADD_FAILURE();
+      }
     }
   }
 
@@ -2431,8 +2465,9 @@ class PopupJSWindowOpenTestHandler : public TestHandler {
                             bool isLoading,
                             bool canGoBack,
                             bool canGoForward) override {
-    if (isLoading)
+    if (isLoading) {
       return;
+    }
 
     if (browser->IsPopup()) {
       const std::string& url = browser->GetMainFrame()->GetURL();
@@ -2478,8 +2513,9 @@ class PopupJSWindowOpenTestHandler : public TestHandler {
     TestHandler::OnBeforeClose(browser);
 
     before_close_ct_++;
-    if (before_close_ct_ == 2U)
+    if (before_close_ct_ == 2U) {
       DestroyTest();
+    }
   }
 
  private:
@@ -2563,8 +2599,9 @@ class PopupJSWindowEmptyTestHandler : public TestHandler {
                             bool isLoading,
                             bool canGoBack,
                             bool canGoForward) override {
-    if (isLoading)
+    if (isLoading) {
       return;
+    }
 
     if (browser->IsPopup()) {
       got_load_end_popup_.yes();
@@ -2706,10 +2743,11 @@ class BrowseNavTestHandler : public TestHandler {
 
       got_loading_state_changed_start_.yes();
     } else {
-      if (allow_)
+      if (allow_) {
         EXPECT_STREQ(kBrowseNavPageUrl, url.c_str());
-      else
+      } else {
         EXPECT_STREQ("", url.c_str());
+      }
 
       got_loading_state_changed_end_.yes();
       DestroyTestIfDone();
@@ -2718,13 +2756,15 @@ class BrowseNavTestHandler : public TestHandler {
 
  private:
   void DestroyTestIfDone() {
-    if (destroyed_)
+    if (destroyed_) {
       return;
+    }
 
     if (got_loading_state_changed_end_) {
       if (allow_) {
-        if (got_load_end_)
+        if (got_load_end_) {
           DestroyTest();
+        }
       } else if (got_load_error_) {
         DestroyTest();
       }
@@ -2732,8 +2772,9 @@ class BrowseNavTestHandler : public TestHandler {
   }
 
   void DestroyTest() override {
-    if (destroyed_)
+    if (destroyed_) {
       return;
+    }
     destroyed_ = true;
 
     EXPECT_TRUE(got_before_browse_);
@@ -2857,10 +2898,11 @@ class SameNavTestHandler : public TestHandler {
 
     if (isLoading) {
       // Verify the previous URL.
-      if (step_ == 0)
+      if (step_ == 0) {
         EXPECT_TRUE(url.empty());
-      else
+      } else {
         EXPECT_STREQ(kSameNavPageUrl, url.c_str());
+      }
 
       got_loading_state_changed_start_.yes();
     } else {
@@ -2900,8 +2942,9 @@ class SameNavTestHandler : public TestHandler {
   }
 
   void DestroyTest() override {
-    if (destroyed_)
+    if (destroyed_) {
       return;
+    }
     destroyed_ = true;
 
     EXPECT_EQ(2, step_);
@@ -3120,8 +3163,9 @@ class CancelBeforeNavTestHandler : public TestHandler {
   }
 
   void DestroyTest() override {
-    if (destroyed_)
+    if (destroyed_) {
       return;
+    }
     destroyed_ = true;
 
     EXPECT_TRUE(got_loading_state_changed_start_);
@@ -3405,13 +3449,15 @@ class CancelAfterNavTestHandler : public TestHandler {
   }
 
   void DestroyTestIfDone() {
-    if (got_loading_state_changed_end_ && got_load_end_)
+    if (got_loading_state_changed_end_ && got_load_end_) {
       DestroyTest();
+    }
   }
 
   void DestroyTest() override {
-    if (destroyed_)
+    if (destroyed_) {
       return;
+    }
     destroyed_ = true;
 
     EXPECT_TRUE(got_loading_state_changed_start_);
@@ -3481,8 +3527,9 @@ class ExtraInfoNavRendererTest : public ClientAppRenderer::Delegate {
                         CefRefPtr<CefBrowser> browser,
                         CefRefPtr<CefDictionaryValue> extra_info) override {
     run_test_ = extra_info && extra_info->HasKey(kExtraInfoTestCmdKey);
-    if (!run_test_)
+    if (!run_test_) {
       return;
+    }
 
     CefRefPtr<CefDictionaryValue> expected = CefDictionaryValue::Create();
     SetBrowserExtraInfo(expected);
diff --git a/tests/ceftests/os_rendering_unittest.cc b/tests/ceftests/os_rendering_unittest.cc
index 8a2beee8d..8fb73879c 100644
--- a/tests/ceftests/os_rendering_unittest.cc
+++ b/tests/ceftests/os_rendering_unittest.cc
@@ -213,8 +213,9 @@ class OSRTestHandler : public RoutingTestHandler,
   void OnLoadEnd(CefRefPtr<CefBrowser> browser,
                  CefRefPtr<CefFrame> frame,
                  int httpStatusCode) override {
-    if (!started())
+    if (!started()) {
       return;
+    }
 
     switch (test_type_) {
       case OSR_TEST_KEY_EVENTS: {
@@ -286,8 +287,9 @@ class OSRTestHandler : public RoutingTestHandler,
             // The first message expected is touchstart.
             // We expect multitouch, so touches length should be 2.
             // Ignore intermediate touch start events.
-            if (messageStr == "osrtouchstart1")
+            if (messageStr == "osrtouchstart1") {
               break;
+            }
             EXPECT_STREQ(messageStr.c_str(), "osrtouchstart2");
             // Close Touch Start Tests.
             if (test_type_ == OSR_TEST_TOUCH_START) {
@@ -525,8 +527,9 @@ class OSRTestHandler : public RoutingTestHandler,
     // start test only when painting something else then background
     if (IsBackgroundInBuffer(
             reinterpret_cast<const uint32*>(buffer), width * height,
-            test_type_ == OSR_TEST_TRANSPARENCY ? 0x00000000 : 0xFFFFFFFF))
+            test_type_ == OSR_TEST_TRANSPARENCY ? 0x00000000 : 0xFFFFFFFF)) {
       return;
+    }
 
     // Send events after the first full repaint
     switch (test_type_) {
@@ -662,8 +665,9 @@ class OSRTestHandler : public RoutingTestHandler,
           const CefRect& expected_rect =
               GetScaledRect(CefRect(0, 0, kOsrWidth, kOsrHeight));
           // There may be some partial repaints before the full repaint.
-          if (dirtyRects[0] == expected_rect)
+          if (dirtyRects[0] == expected_rect) {
             DestroySucceededTestSoon();
+          }
         }
         break;
       }
@@ -731,8 +735,9 @@ class OSRTestHandler : public RoutingTestHandler,
           const CefRect& expected_rect =
               GetScaledRect(CefRect(0, 0, kOsrWidth, kOsrHeight));
           // There may be some partial repaints before the full repaint.
-          if (dirtyRects[0] == expected_rect)
+          if (dirtyRects[0] == expected_rect) {
             DestroySucceededTestSoon();
+          }
         }
         break;
       }
@@ -1104,10 +1109,11 @@ class OSRTestHandler : public RoutingTestHandler,
           }
 
           // Now release the Touch fingers or cancel them
-          if (test_type_ == OSR_TEST_TOUCH_CANCEL)
+          if (test_type_ == OSR_TEST_TOUCH_CANCEL) {
             touch_event1.type = touch_event2.type = CEF_TET_CANCELLED;
-          else
+          } else {
             touch_event1.type = touch_event2.type = CEF_TET_RELEASED;
+          }
           browser->GetHost()->SendTouchEvent(touch_event1);
           browser->GetHost()->SendTouchEvent(touch_event2);
         }
@@ -1144,8 +1150,9 @@ class OSRTestHandler : public RoutingTestHandler,
 
       // Ignore focus from the original navigation when we're testing focus
       // event delivery.
-      if (test_type_ == OSR_TEST_FOCUS)
+      if (test_type_ == OSR_TEST_FOCUS) {
         return true;
+      }
       return false;
     }
 
@@ -1260,8 +1267,9 @@ class OSRTestHandler : public RoutingTestHandler,
       }
     } else if (test_type_ == OSR_TEST_DRAG_DROP_DROP && started()) {
       // Don't end the drag multiple times.
-      if (got_update_cursor_)
+      if (got_update_cursor_) {
         return;
+      }
       got_update_cursor_.yes();
 
       CefMouseEvent ev;
@@ -1323,8 +1331,9 @@ class OSRTestHandler : public RoutingTestHandler,
                            CefRefPtr<CefFrame> frame,
                            CefRefPtr<CefContextMenuParams> params,
                            CefRefPtr<CefMenuModel> model) override {
-    if (!started())
+    if (!started()) {
       return;
+    }
     if (test_type_ == OSR_TEST_CLICK_RIGHT) {
       const CefRect& expected_rect = GetElementBounds("LI04");
       EXPECT_EQ(params->GetXCoord(), MiddleX(expected_rect));
@@ -1341,8 +1350,9 @@ class OSRTestHandler : public RoutingTestHandler,
                       CefRefPtr<CefContextMenuParams> params,
                       CefRefPtr<CefMenuModel> model,
                       CefRefPtr<CefRunContextMenuCallback> callback) override {
-    if (!started())
+    if (!started()) {
       return false;
+    }
 
     EXPECT_UI_THREAD();
 
@@ -1379,8 +1389,9 @@ class OSRTestHandler : public RoutingTestHandler,
                     const CefSize& size,
                     QuickMenuEditStateFlags edit_state_flags,
                     CefRefPtr<CefRunQuickMenuCallback> callback) override {
-    if (!started())
+    if (!started()) {
       return false;
+    }
 
     EXPECT_UI_THREAD();
 
@@ -1480,8 +1491,9 @@ class OSRTestHandler : public RoutingTestHandler,
 
   void OnTouchHandleStateChanged(CefRefPtr<CefBrowser> browser,
                                  const CefTouchHandleState& state) override {
-    if (!started())
+    if (!started()) {
       return;
+    }
 
     EXPECT_UI_THREAD();
 
@@ -1556,10 +1568,11 @@ class OSRTestHandler : public RoutingTestHandler,
 #elif defined(OS_MAC)
     // An actual vies is needed only for the ContextMenu test. The menu runner
     // checks if the view is not nil before showing the context menu.
-    if (test_type_ == OSR_TEST_CONTEXT_MENU)
+    if (test_type_ == OSR_TEST_CONTEXT_MENU) {
       windowInfo.SetAsWindowless(osr_unittests::GetFakeView());
-    else
+    } else {
       windowInfo.SetAsWindowless(kNullWindowHandle);
+    }
 #elif defined(OS_LINUX)
     windowInfo.SetAsWindowless(kNullWindowHandle);
 #else
@@ -1620,8 +1633,9 @@ class OSRTestHandler : public RoutingTestHandler,
   }
 
   void DestroySucceededTestSoon() {
-    if (succeeded())
+    if (succeeded()) {
       return;
+    }
     if (++event_count_ == event_total_) {
       CefPostTask(TID_UI, base::BindOnce(&OSRTestHandler::DestroyTest, this));
     }
@@ -1725,8 +1739,9 @@ class OSRTestHandler : public RoutingTestHandler,
   // will mark test as started and will return true only the first time
   // it is called
   bool StartTest() {
-    if (started_)
+    if (started_) {
       return false;
+    }
     started_ = true;
     return true;
   }
diff --git a/tests/ceftests/osr_accessibility_unittest.cc b/tests/ceftests/osr_accessibility_unittest.cc
index 77fdf6e71..abb10e007 100644
--- a/tests/ceftests/osr_accessibility_unittest.cc
+++ b/tests/ceftests/osr_accessibility_unittest.cc
@@ -171,8 +171,9 @@ class AccessibilityTestHandler : public TestHandler,
         } else {
           // Retrieve the "focus" event.
           CefRefPtr<CefDictionaryValue> event;
-          if (!GetFirstMatchingEvent(value, "focus", event))
+          if (!GetFirstMatchingEvent(value, "focus", event)) {
             return;
+          }
           EXPECT_TRUE(event.get());
 
           // Verify that focus is set to expected element edit_box.
@@ -268,16 +269,18 @@ class AccessibilityTestHandler : public TestHandler,
 
   static size_t GetUpdateListSize(CefRefPtr<CefValue> value) {
     CefRefPtr<CefListValue> updates = GetUpdateList(value);
-    if (updates)
+    if (updates) {
       return updates->GetSize();
+    }
     return 0U;
   }
 
   static CefRefPtr<CefDictionaryValue> GetUpdateValue(CefRefPtr<CefValue> value,
                                                       size_t index) {
     CefRefPtr<CefListValue> updates = GetUpdateList(value);
-    if (!updates)
+    if (!updates) {
       return nullptr;
+    }
     EXPECT_LT(index, updates->GetSize());
     CefRefPtr<CefDictionaryValue> update = updates->GetDictionary(index);
     EXPECT_TRUE(update);
@@ -295,16 +298,18 @@ class AccessibilityTestHandler : public TestHandler,
 
   static size_t GetEventListSize(CefRefPtr<CefValue> value) {
     CefRefPtr<CefListValue> events = GetEventList(value);
-    if (events)
+    if (events) {
       return events->GetSize();
+    }
     return 0U;
   }
 
   static CefRefPtr<CefDictionaryValue> GetEventValue(CefRefPtr<CefValue> value,
                                                      size_t index) {
     CefRefPtr<CefListValue> events = GetEventList(value);
-    if (!events)
+    if (!events) {
       return nullptr;
+    }
     EXPECT_LT(index, events->GetSize());
     CefRefPtr<CefDictionaryValue> event = events->GetDictionary(index);
     EXPECT_TRUE(event);
@@ -314,10 +319,12 @@ class AccessibilityTestHandler : public TestHandler,
   static void GetFirstUpdateAndEvent(CefRefPtr<CefValue> value,
                                      CefRefPtr<CefDictionaryValue>& update,
                                      CefRefPtr<CefDictionaryValue>& event) {
-    if (GetUpdateListSize(value) > 0U)
+    if (GetUpdateListSize(value) > 0U) {
       update = GetUpdateValue(value, 0U);
-    if (GetEventListSize(value) > 0U)
+    }
+    if (GetEventListSize(value) > 0U) {
       event = GetEventValue(value, 0U);
+    }
   }
 
   static bool GetFirstMatchingEvent(CefRefPtr<CefValue> value,
diff --git a/tests/ceftests/osr_display_unittest.cc b/tests/ceftests/osr_display_unittest.cc
index 9721689a2..05a6a04ab 100644
--- a/tests/ceftests/osr_display_unittest.cc
+++ b/tests/ceftests/osr_display_unittest.cc
@@ -255,8 +255,9 @@ class OsrPopupJSOtherClientTestHandler : public TestHandler,
                             bool isLoading,
                             bool canGoBack,
                             bool canGoForward) override {
-    if (isLoading)
+    if (isLoading) {
       return;
+    }
 
     if (browser->IsPopup()) {
       got_load_end_popup_.yes();
diff --git a/tests/ceftests/pdf_viewer_unittest.cc b/tests/ceftests/pdf_viewer_unittest.cc
index 0a6b77bff..a325b0af7 100644
--- a/tests/ceftests/pdf_viewer_unittest.cc
+++ b/tests/ceftests/pdf_viewer_unittest.cc
@@ -92,14 +92,16 @@ class PdfViewerTestHandler : public TestHandler, public CefContextMenuHandler {
                  int httpStatusCode) override {
     bool is_pdf1 = false;
     const std::string& url = frame->GetURL();
-    if (url == "about:blank")
+    if (url == "about:blank") {
       return;
+    }
 
     if (url == kPdfHtmlUrl) {
-      if (!got_on_load_end_html_)
+      if (!got_on_load_end_html_) {
         got_on_load_end_html_.yes();
-      else
+      } else {
         NOTREACHED();
+      }
     } else if (url == kPdfDirectUrl) {
       if (!got_on_load_end_pdf1_) {
         got_on_load_end_pdf1_.yes();
diff --git a/tests/ceftests/permission_prompt_unittest.cc b/tests/ceftests/permission_prompt_unittest.cc
index 6cd1acabf..c36c637ba 100644
--- a/tests/ceftests/permission_prompt_unittest.cc
+++ b/tests/ceftests/permission_prompt_unittest.cc
@@ -180,8 +180,9 @@ class PermissionPromptTestHandler : public TestHandler,
   void OnLoadEnd(CefRefPtr<CefBrowser> browser,
                  CefRefPtr<CefFrame> frame,
                  int httpStatusCode) override {
-    if (test_setup_->deny_no_gesture)
+    if (test_setup_->deny_no_gesture) {
       return;
+    }
 
     if (test_setup_->deny_with_navigation) {
       if (frame->GetURL().ToString() == kPromptNavUrl) {
diff --git a/tests/ceftests/print_unittest.cc b/tests/ceftests/print_unittest.cc
index 3a81edc47..d05848c04 100644
--- a/tests/ceftests/print_unittest.cc
+++ b/tests/ceftests/print_unittest.cc
@@ -38,8 +38,9 @@ TEST(PrintTest, SettingsSetGet) {
   CefPrintSettings::PageRangeList page_ranges2;
   settings->GetPageRanges(page_ranges2);
   EXPECT_EQ(page_ranges.size(), page_ranges2.size());
-  for (size_t i = 0; i < page_ranges.size(); ++i)
+  for (size_t i = 0; i < page_ranges.size(); ++i) {
     EXPECT_EQ(page_ranges[i], page_ranges2[i]);
+  }
 
   bool selection_only = true;
   settings->SetSelectionOnly(selection_only);
diff --git a/tests/ceftests/request_context_unittest.cc b/tests/ceftests/request_context_unittest.cc
index 1f7aa5af7..c24ca9efa 100644
--- a/tests/ceftests/request_context_unittest.cc
+++ b/tests/ceftests/request_context_unittest.cc
@@ -207,10 +207,11 @@ class PopupTestHandler : public TestHandler {
 
   PopupTestHandler(bool same_origin, Mode mode) : mode_(mode) {
     url_ = "http://tests-simple-rch1.com/nav1.html";
-    if (same_origin)
+    if (same_origin) {
       popup_url_ = "http://tests-simple-rch1.com/pop1.html";
-    else
+    } else {
       popup_url_ = "http://tests-simple-rch2.com/pop1.html";
+    }
   }
 
   void RunTest() override {
@@ -297,10 +298,11 @@ class PopupTestHandler : public TestHandler {
 
     EXPECT_EQ(WOD_NEW_FOREGROUND_TAB, target_disposition);
 
-    if (mode_ == MODE_WINDOW_OPEN)
+    if (mode_ == MODE_WINDOW_OPEN) {
       EXPECT_FALSE(user_gesture);
-    else
+    } else {
       EXPECT_TRUE(user_gesture);
+    }
 
     return false;
   }
@@ -308,8 +310,9 @@ class PopupTestHandler : public TestHandler {
   void OnBeforeClose(CefRefPtr<CefBrowser> browser) override {
     TestHandler::OnBeforeClose(browser);
 
-    if (browser->IsPopup())
+    if (browser->IsPopup()) {
       FinishTest();
+    }
   }
 
  protected:
@@ -488,8 +491,9 @@ class PopupNavTestHandler : public TestHandler {
                        "'); }</script>Page</html>";
     AddResource(kPopupNavPageUrl, page, "text/html");
     AddResource(kPopupNavPopupUrl, "<html>Popup</html>", "text/html");
-    if (mode_ == NAVIGATE_AFTER_CREATION)
+    if (mode_ == NAVIGATE_AFTER_CREATION) {
       AddResource(kPopupNavPopupUrl2, "<html>Popup2</html>", "text/html");
+    }
 
     CefRefPtr<CefRequestContext> request_context =
         CreateTestRequestContext(rc_mode_, rc_cache_path_);
@@ -640,8 +644,9 @@ class PopupNavTestHandler : public TestHandler {
     bool destroy_test = false;
     if (mode_ == ALLOW_CLOSE_POPUP_FIRST || mode_ == NAVIGATE_AFTER_CREATION) {
       // Destroy the test after the popup browser closes.
-      if (browser->IsPopup())
+      if (browser->IsPopup()) {
         destroy_test = true;
+      }
     } else if (mode_ == ALLOW_CLOSE_POPUP_LAST ||
                mode_ == DESTROY_PARENT_BEFORE_CREATION ||
                mode_ == DESTROY_PARENT_BEFORE_CREATION_FORCE ||
@@ -650,8 +655,9 @@ class PopupNavTestHandler : public TestHandler {
                mode_ == DESTROY_PARENT_AFTER_CREATION ||
                mode_ == DESTROY_PARENT_AFTER_CREATION_FORCE) {
       // Destroy the test after the main browser closes.
-      if (!browser->IsPopup())
+      if (!browser->IsPopup()) {
         destroy_test = true;
+      }
     }
 
     if (destroy_test) {
@@ -836,12 +842,13 @@ class MethodTestHandler : public TestHandler {
         browser->GetHost()->GetRequestContext();
     CefRefPtr<CompletionCallback> callback =
         new CompletionCallback(this, browser);
-    if (method_ == METHOD_CLEAR_CERTIFICATE_EXCEPTIONS)
+    if (method_ == METHOD_CLEAR_CERTIFICATE_EXCEPTIONS) {
       context->ClearCertificateExceptions(callback);
-    else if (method_ == METHOD_CLOSE_ALL_CONNECTIONS)
+    } else if (method_ == METHOD_CLOSE_ALL_CONNECTIONS) {
       context->CloseAllConnections(callback);
-    else if (method_ == METHOD_RESOLVE_HOST)
+    } else if (method_ == METHOD_RESOLVE_HOST) {
       context->ResolveHost(kResolveOrigin, callback);
+    }
   }
 
   void OnCompleteCallback(CefRefPtr<CefBrowser> browser) {
diff --git a/tests/ceftests/request_handler_unittest.cc b/tests/ceftests/request_handler_unittest.cc
index fe73f77ae..a86df2448 100644
--- a/tests/ceftests/request_handler_unittest.cc
+++ b/tests/ceftests/request_handler_unittest.cc
@@ -101,15 +101,17 @@ class NetNotifyTestHandler : public TestHandler {
     EXPECT_TRUE(CefCurrentlyOn(TID_IO));
 
     const std::string& url = request->GetURL();
-    if (IgnoreURL(url))
+    if (IgnoreURL(url)) {
       return RV_CONTINUE;
+    }
 
-    if (url.find(url1_) == 0)
+    if (url.find(url1_) == 0) {
       got_before_resource_load1_.yes();
-    else if (url.find(url2_) == 0)
+    } else if (url.find(url2_) == 0) {
       got_before_resource_load2_.yes();
-    else
+    } else {
       EXPECT_TRUE(false);  // Not reached
+    }
 
     return RV_CONTINUE;
   }
@@ -121,15 +123,17 @@ class NetNotifyTestHandler : public TestHandler {
     EXPECT_TRUE(CefCurrentlyOn(TID_IO));
 
     const std::string& url = request->GetURL();
-    if (IgnoreURL(url))
+    if (IgnoreURL(url)) {
       return nullptr;
+    }
 
-    if (url.find(url1_) == 0)
+    if (url.find(url1_) == 0) {
       got_get_resource_handler1_.yes();
-    else if (url.find(url2_) == 0)
+    } else if (url.find(url2_) == 0) {
       got_get_resource_handler2_.yes();
-    else
+    } else {
       EXPECT_TRUE(false);  // Not reached
+    }
 
     return TestHandler::GetResourceHandler(browser, frame, request);
   }
@@ -143,8 +147,9 @@ class NetNotifyTestHandler : public TestHandler {
     EXPECT_TRUE(CefCurrentlyOn(TID_IO));
 
     const std::string& url = request->GetURL();
-    if (IgnoreURL(url))
+    if (IgnoreURL(url)) {
       return;
+    }
 
     EXPECT_EQ(UR_SUCCESS, status);
     if (url.find(url1_) == 0) {
@@ -268,13 +273,15 @@ class NetNotifyTestHandler : public TestHandler {
 
  protected:
   void SetupCompleteIfDone() {
-    if (got_load_end1_ && got_process_message1_)
+    if (got_load_end1_ && got_process_message1_) {
       SetupComplete();
+    }
   }
 
   void FinishTestIfDone() {
-    if (got_load_end2_ && got_process_message2_)
+    if (got_load_end2_ && got_process_message2_) {
       FinishTest();
+    }
   }
 
   void FinishTest() {
@@ -406,16 +413,18 @@ class NetNotifyRendererTest : public ClientAppRenderer::Delegate,
 
   CefRefPtr<CefLoadHandler> GetLoadHandler(
       CefRefPtr<ClientAppRenderer> app) override {
-    if (run_test_)
+    if (run_test_) {
       return this;
+    }
     return nullptr;
   }
 
   void OnLoadEnd(CefRefPtr<CefBrowser> browser,
                  CefRefPtr<CefFrame> frame,
                  int httpStatusCode) override {
-    if (!run_test_)
+    if (!run_test_) {
       return;
+    }
 
     const std::string& url = frame->GetURL();
 
diff --git a/tests/ceftests/request_unittest.cc b/tests/ceftests/request_unittest.cc
index 51209c222..46d463dd4 100644
--- a/tests/ceftests/request_unittest.cc
+++ b/tests/ceftests/request_unittest.cc
@@ -72,10 +72,11 @@ TEST(RequestTest, SetGet) {
   postData->GetElements(elements);
   CefPostData::ElementVector::const_iterator it = elements.begin();
   for (size_t i = 0; it != elements.end(); ++it, ++i) {
-    if (i == 0)
+    if (i == 0) {
       TestPostDataElementEqual(element1, (*it).get());
-    else if (i == 1)
+    } else if (i == 1) {
       TestPostDataElementEqual(element2, (*it).get());
+    }
   }
 
   // CefRequest SetURL
@@ -419,8 +420,9 @@ class TypeExpectations {
     for (int i = 0;
          i < static_cast<int>(sizeof(g_type_expected) / sizeof(TypeExpected));
          ++i) {
-      if (navigation_ && g_type_expected[i].navigation != navigation_)
+      if (navigation_ && g_type_expected[i].navigation != navigation_) {
         continue;
+      }
 
       request_count_.insert(std::make_pair(i, 0));
     }
@@ -430,8 +432,9 @@ class TypeExpectations {
   // something we care about.
   bool GotRequest(CefRefPtr<CefRequest> request) {
     const std::string& url = request->GetURL();
-    if (url.find(kTypeTestOrigin) != 0)
+    if (url.find(kTypeTestOrigin) != 0) {
       return false;
+    }
 
     const std::string& file = url.substr(sizeof(kTypeTestOrigin) - 1);
     cef_transition_type_t transition_type = request->GetTransitionType();
@@ -461,8 +464,9 @@ class TypeExpectations {
     for (int i = 0;
          i < static_cast<int>(sizeof(g_type_expected) / sizeof(TypeExpected));
          ++i) {
-      if (navigation_ && g_type_expected[i].navigation != navigation_)
+      if (navigation_ && g_type_expected[i].navigation != navigation_) {
         continue;
+      }
 
       RequestCount::const_iterator it = request_count_.find(i);
       EXPECT_TRUE(it != request_count_.end());
@@ -594,8 +598,9 @@ class TypeTestHandler : public TestHandler {
 
  private:
   void DestroyTest() override {
-    if (destroyed_)
+    if (destroyed_) {
       return;
+    }
     destroyed_ = true;
 
     // Verify test expectations.
diff --git a/tests/ceftests/resource_manager_unittest.cc b/tests/ceftests/resource_manager_unittest.cc
index 7dd322406..f4904c329 100644
--- a/tests/ceftests/resource_manager_unittest.cc
+++ b/tests/ceftests/resource_manager_unittest.cc
@@ -109,8 +109,9 @@ class ResourceManagerTestHandler : public RoutingTestHandler {
     if (state_->manager_) {
       CefRefPtr<CefResourceHandler> handler =
           state_->manager_->GetResourceHandler(browser, frame, request);
-      if (handler.get())
+      if (handler.get()) {
         return handler;
+      }
     }
 
     return CreateContentsResourceHandler(CreateMessage(kDoneMsg, kNotHandled));
@@ -143,18 +144,20 @@ class ResourceManagerTestHandler : public RoutingTestHandler {
     if (state_->expected_message_ct_ == 0) {
       // Load each URL sequentially.
       const std::string& next_url = GetNextURL();
-      if (next_url.empty())
+      if (next_url.empty()) {
         DestroyTest();
-      else
+      } else {
         browser->GetMainFrame()->LoadURL(next_url);
+      }
     } else if (state_->messages_.size() == state_->expected_message_ct_) {
       DestroyTest();
     }
   }
 
   std::string GetNextURL() {
-    if (current_url_ >= state_->urls_.size())
+    if (current_url_ >= state_->urls_.size()) {
       return std::string();
+    }
     return state_->urls_[current_url_++];
   }
 
@@ -205,8 +208,9 @@ class TestProvider : public CefResourceManager::Provider {
   ~TestProvider() {
     CEF_REQUIRE_IO_THREAD();
     state_->got_destruct_.yes();
-    if (!state_->destruct_callback_.is_null())
+    if (!state_->destruct_callback_.is_null()) {
       std::move(state_->destruct_callback_).Run();
+    }
   }
 
   bool OnRequest(scoped_refptr<CefResourceManager::Request> request) override {
@@ -260,8 +264,9 @@ class ProviderDestructHelper {
     {
       base::AutoLock lock_scope(lock_);
       CHECK_LT(current_count_, expected_count_);
-      if (++current_count_ == expected_count_)
+      if (++current_count_ == expected_count_) {
         signal = true;
+      }
     }
 
     if (signal) {
@@ -371,17 +376,17 @@ class SimpleTestProvider : public TestProvider {
   bool OnRequest(scoped_refptr<CefResourceManager::Request> request) override {
     TestProvider::OnRequest(request);
 
-    if (mode_ == NOT_HANDLED)
+    if (mode_ == NOT_HANDLED) {
       return false;
-    else if (mode_ == CONTINUE)
+    } else if (mode_ == CONTINUE) {
       request->Continue(nullptr);
-    else if (mode_ == STOP)
+    } else if (mode_ == STOP) {
       request->Stop();
-    else if (mode_ == REMOVE)
+    } else if (mode_ == REMOVE) {
       manager_->RemoveProviders(kProviderId);
-    else if (mode_ == REMOVE_ALL)
+    } else if (mode_ == REMOVE_ALL) {
       manager_->RemoveAllProviders();
-    else if (mode_ == DO_NOTHING) {
+    } else if (mode_ == DO_NOTHING) {
       EXPECT_FALSE(do_nothing_callback_.is_null());
       std::move(do_nothing_callback_).Run();
     }
@@ -1108,20 +1113,22 @@ class OneShotRemovalProvider : public TestProvider {
     if (remove_before_continue_) {
       // Removing the provider before continuing should trigger a call to
       // OnRequestCanceled.
-      if (identifier_.empty())
+      if (identifier_.empty()) {
         manager_->RemoveAllProviders();
-      else
+      } else {
         manager_->RemoveProviders(identifier_);
+      }
     }
 
     request->Continue(new CefStreamResourceHandler("text/html", stream));
 
     if (!remove_before_continue_) {
       // The request has already completed so OnRequestCanceled is not called.
-      if (identifier_.empty())
+      if (identifier_.empty()) {
         manager_->RemoveAllProviders();
-      else
+      } else {
         manager_->RemoveProviders(identifier_);
+      }
     }
 
     return true;
@@ -1544,16 +1551,18 @@ std::string TestUrlFilter(const std::string& url) {
 // Add to the URL but keep the query component.
 std::string TestUrlFilterWithQuery(const std::string& url) {
   size_t pos = url.find('?');
-  if (pos == std::string::npos)
+  if (pos == std::string::npos) {
     return url;
+  }
   return url.substr(0, pos) + "Rewrite" + url.substr(pos);
 }
 
 // Add to the URL but keep the fragment component.
 std::string TestUrlFilterWithFragment(const std::string& url) {
   size_t pos = url.find('#');
-  if (pos == std::string::npos)
+  if (pos == std::string::npos) {
     return url;
+  }
   return url.substr(0, pos) + "Rewrite" + url.substr(pos);
 }
 
diff --git a/tests/ceftests/resource_request_handler_unittest.cc b/tests/ceftests/resource_request_handler_unittest.cc
index 92d276a13..ecfb782db 100644
--- a/tests/ceftests/resource_request_handler_unittest.cc
+++ b/tests/ceftests/resource_request_handler_unittest.cc
@@ -135,8 +135,9 @@ class CallbackResourceHandler : public CefResourceHandler {
     response->SetStatusText(status_text_);
     response->SetMimeType(mime_type_);
 
-    if (!header_map_.empty())
+    if (!header_map_.empty()) {
       response->SetHeaderMap(header_map_);
+    }
 
     response_length = -1;
   }
@@ -672,13 +673,15 @@ class BasicResponseTest : public TestHandler {
         return GetOKResource();
       } else {
         // Restarted request.
-        if (unhandled_)
+        if (unhandled_) {
           return nullptr;
+        }
         return GetOKResource();
       }
     } else if (url == GetURL(RESULT_HTML)) {
-      if (unhandled_)
+      if (unhandled_) {
         return nullptr;
+      }
       return GetOKResource();
     } else if (url == GetURL(REDIRECT_HTML) &&
                mode_ == REDIRECT_RESOURCE_RESPONSE) {
@@ -687,8 +690,9 @@ class BasicResponseTest : public TestHandler {
         return GetOKResource();
       } else {
         // Redirected request.
-        if (unhandled_)
+        if (unhandled_) {
           return nullptr;
+        }
         return GetOKResource();
       }
     } else if (url == GetURL(REDIRECT_HTML) || url == GetURL(REDIRECT2_HTML)) {
@@ -1006,19 +1010,25 @@ class BasicResponseTest : public TestHandler {
 
   const char* GetURL(TestUrl url) const {
     if (custom_scheme_) {
-      if (url == RESULT_HTML)
+      if (url == RESULT_HTML) {
         return "rrhcustom://test.com/result.html";
-      if (url == REDIRECT_HTML)
+      }
+      if (url == REDIRECT_HTML) {
         return "rrhcustom://test.com/redirect.html";
-      if (url == REDIRECT2_HTML)
+      }
+      if (url == REDIRECT2_HTML) {
         return "rrhcustom://test.com/redirect2.html";
+      }
     } else {
-      if (url == RESULT_HTML)
+      if (url == RESULT_HTML) {
         return "http://test.com/result.html";
-      if (url == REDIRECT_HTML)
+      }
+      if (url == REDIRECT_HTML) {
         return "http://test.com/redirect.html";
-      if (url == REDIRECT2_HTML)
+      }
+      if (url == REDIRECT2_HTML) {
         return "http://test.com/redirect2.html";
+      }
     }
 
     NOTREACHED();
@@ -1234,8 +1244,9 @@ class BasicResponseTest : public TestHandler {
         EXPECT_STREQ("", custom_header.c_str()) << callback;
       }
 
-      if (response)
+      if (response) {
         VerifyOKResponse(callback, response);
+      }
     } else if (IsRedirect()) {
       EXPECT_STREQ("GET", request->GetMethod().ToString().c_str()) << callback;
       if (on_before_browse_ct_ == 1) {
@@ -1572,8 +1583,9 @@ class SubresourceResponseTest : public RoutingTestHandler {
     EXPECT_EQ(browser_id_, browser->GetIdentifier());
 
     const std::string& url = request->GetURL();
-    if (IgnoreURL(url))
+    if (IgnoreURL(url)) {
       return nullptr;
+    }
 
     const bool is_main_url = IsMainURL(url);
     const bool is_sub_url = IsSubURL(url);
@@ -1591,8 +1603,9 @@ class SubresourceResponseTest : public RoutingTestHandler {
       // return -4 (kInvalidFrameId) for the initial navigation.
       if (frame_id_ == 0) {
         if (subframe_) {
-          if (is_sub_url)
+          if (is_sub_url) {
             frame_id_ = frame->GetIdentifier();
+          }
         } else {
           frame_id_ = frame->GetIdentifier();
         }
@@ -1638,8 +1651,9 @@ class SubresourceResponseTest : public RoutingTestHandler {
     EXPECT_EQ(browser_id_, browser->GetIdentifier());
 
     const std::string& url = request->GetURL();
-    if (IgnoreURL(url))
+    if (IgnoreURL(url)) {
       return nullptr;
+    }
 
     if (IsMainURL(url)) {
       EXPECT_TRUE(frame->IsMain());
@@ -1744,13 +1758,15 @@ class SubresourceResponseTest : public RoutingTestHandler {
         return GetOKResource();
       } else {
         // Restarted request.
-        if (unhandled_)
+        if (unhandled_) {
           return nullptr;
+        }
         return GetOKResource();
       }
     } else if (url == GetURL(RESULT_JS)) {
-      if (unhandled_)
+      if (unhandled_) {
         return nullptr;
+      }
       return GetOKResource();
     } else if (url == GetURL(REDIRECT_JS) &&
                mode_ == REDIRECT_RESOURCE_RESPONSE) {
@@ -1759,8 +1775,9 @@ class SubresourceResponseTest : public RoutingTestHandler {
         return GetOKResource();
       } else {
         // Redirected request.
-        if (unhandled_)
+        if (unhandled_) {
           return nullptr;
+        }
         return GetOKResource();
       }
     } else if (url == GetURL(REDIRECT_JS) || url == GetURL(REDIRECT2_JS)) {
@@ -2041,23 +2058,26 @@ class SubresourceResponseTest : public RoutingTestHandler {
       EXPECT_EQ(1, on_resource_redirect_ct_);
 
       // Unhandled requests won't see a call to GetResourceResponseFilter.
-      if (unhandled_)
+      if (unhandled_) {
         EXPECT_EQ(0, get_resource_response_filter_ct_);
-      else
+      } else {
         EXPECT_EQ(1, get_resource_response_filter_ct_);
+      }
 
       // Unhandled requests won't see a call to OnResourceResponse.
       if (mode_ == REDIRECT_RESOURCE_RESPONSE) {
         // In this case we're redirecting from inside OnResourceResponse.
-        if (unhandled_)
+        if (unhandled_) {
           EXPECT_EQ(1, on_resource_response_ct_);
-        else
+        } else {
           EXPECT_EQ(2, on_resource_response_ct_);
+        }
       } else {
-        if (unhandled_)
+        if (unhandled_) {
           EXPECT_EQ(0, on_resource_response_ct_);
-        else
+        } else {
           EXPECT_EQ(1, on_resource_response_ct_);
+        }
       }
     } else if (IsIncomplete()) {
       EXPECT_EQ(1, get_resource_request_handler_ct_);
@@ -2154,19 +2174,25 @@ class SubresourceResponseTest : public RoutingTestHandler {
 
   const char* GetURL(TestUrl url) const {
     if (custom_scheme_) {
-      if (url == RESULT_JS)
+      if (url == RESULT_JS) {
         return "rrhcustom://test.com/result.js";
-      if (url == REDIRECT_JS)
+      }
+      if (url == REDIRECT_JS) {
         return "rrhcustom://test.com/redirect.js";
-      if (url == REDIRECT2_JS)
+      }
+      if (url == REDIRECT2_JS) {
         return "rrhcustom://test.com/redirect2.js";
+      }
     } else {
-      if (url == RESULT_JS)
+      if (url == RESULT_JS) {
         return "http://test.com/result.js";
-      if (url == REDIRECT_JS)
+      }
+      if (url == REDIRECT_JS) {
         return "http://test.com/redirect.js";
-      if (url == REDIRECT2_JS)
+      }
+      if (url == REDIRECT2_JS) {
         return "http://test.com/redirect2.js";
+      }
     }
 
     NOTREACHED();
@@ -2379,10 +2405,11 @@ class SubresourceResponseTest : public RoutingTestHandler {
   void VerifyFrame(Callback callback, CefRefPtr<CefFrame> frame) const {
     EXPECT_TRUE(frame);
 
-    if (subframe_)
+    if (subframe_) {
       EXPECT_FALSE(frame->IsMain()) << callback;
-    else
+    } else {
       EXPECT_TRUE(frame->IsMain()) << callback;
+    }
 
     EXPECT_EQ(frame_id_, frame->GetIdentifier()) << callback;
   }
@@ -2425,8 +2452,9 @@ class SubresourceResponseTest : public RoutingTestHandler {
         EXPECT_STREQ("", custom_header.c_str()) << callback;
       }
 
-      if (response)
+      if (response) {
         VerifyOKResponse(callback, response);
+      }
     } else if (IsRedirect()) {
       EXPECT_STREQ("GET", request->GetMethod().ToString().c_str()) << callback;
       // Subresource loads don't get OnBeforeBrowse calls, so this check is a
@@ -2665,12 +2693,13 @@ class RedirectResponseTest : public TestHandler {
 
   RedirectResponseTest(TestMode mode, bool via_request_context_handler)
       : via_request_context_handler_(via_request_context_handler) {
-    if (mode == URL)
+    if (mode == URL) {
       resource_test_.reset(new UrlResourceTest);
-    else if (mode == HEADER)
+    } else if (mode == HEADER) {
       resource_test_.reset(new HeaderResourceTest);
-    else
+    } else {
       resource_test_.reset(new PostResourceTest);
+    }
   }
 
   void RunTest() override {
@@ -2910,8 +2939,9 @@ class RedirectResponseTest : public TestHandler {
     }
 
     bool CheckUrl(const std::string& url) const override {
-      if (url == redirect_url_)
+      if (url == redirect_url_) {
         return true;
+      }
 
       return ResourceTest::CheckUrl(url);
     }
@@ -3328,10 +3358,11 @@ class BeforeResourceLoadTest : public TestHandler {
     got_load_end_.yes();
 
     const std::string& url = frame->GetURL();
-    if (test_mode_ == CANCEL_NAV)
+    if (test_mode_ == CANCEL_NAV) {
       EXPECT_STREQ(kResourceTestHtml2, url.data());
-    else
+    } else {
       EXPECT_STREQ(kResourceTestHtml, url.data());
+    }
 
     TestHandler::OnLoadEnd(browser, frame, httpStatusCode);
     DestroyTest();
@@ -3351,17 +3382,19 @@ class BeforeResourceLoadTest : public TestHandler {
     EXPECT_STREQ(kResourceTestHtml, url.data());
 
     TestHandler::OnLoadError(browser, frame, errorCode, errorText, failedUrl);
-    if (test_mode_ != CANCEL_NAV)
+    if (test_mode_ != CANCEL_NAV) {
       DestroyTest();
+    }
   }
 
   void DestroyTest() override {
     EXPECT_TRUE(got_before_resource_load_);
 
-    if (test_mode_ == CANCEL_NAV)
+    if (test_mode_ == CANCEL_NAV) {
       EXPECT_TRUE(got_before_resource_load2_);
-    else
+    } else {
       EXPECT_FALSE(got_before_resource_load2_);
+    }
 
     if (test_mode_ == CONTINUE || test_mode_ == CONTINUE_ASYNC) {
       EXPECT_TRUE(got_load_end_);
@@ -3456,15 +3489,17 @@ std::string CreateInput(const std::string& content,
   size_t repeat_ct =
       static_cast<size_t>(std::ceil(static_cast<double>(desired_min_size) /
                                     static_cast<double>(content.size())));
-  if (calculated_repeat_ct)
+  if (calculated_repeat_ct) {
     *calculated_repeat_ct = repeat_ct;
+  }
 
   std::string result;
   result.reserve(header_footer_size + (content.size() * repeat_ct));
 
   result = kInputHeader;
-  while (repeat_ct--)
+  while (repeat_ct--) {
     result += content;
+  }
   result += kInputFooter;
 
   return result;
@@ -3478,8 +3513,9 @@ std::string CreateOutput(const std::string& content, size_t repeat_ct) {
   result.reserve(header_footer_size + (content.size() * repeat_ct));
 
   result = kInputHeader;
-  while (repeat_ct--)
+  while (repeat_ct--) {
     result += content;
+  }
   result += kInputFooter;
 
   return result;
@@ -3502,10 +3538,11 @@ class ResponseFilterTestBase : public CefResponseFilter {
                       void* data_out,
                       size_t data_out_size,
                       size_t& data_out_written) override {
-    if (data_in_size == 0U)
+    if (data_in_size == 0U) {
       EXPECT_FALSE(data_in);
-    else
+    } else {
       EXPECT_TRUE(data_in);
+    }
     EXPECT_EQ(data_in_read, 0U);
     EXPECT_TRUE(data_out);
     EXPECT_GT(data_out_size, 0U);
@@ -3575,11 +3612,11 @@ class ResponseFilterPassThru : public ResponseFilterTestBase {
     ResponseFilterTestBase::VerifyOutput(status, received_content_length,
                                          received_content);
 
-    if (limit_read_)
+    if (limit_read_) {
       // Expected to read 2 full buffers of GetResponseBufferSize() at 1kb
       // increments and one partial buffer.
       EXPECT_EQ(2U * (GetResponseBufferSize() / 1024) + 1U, filter_count_);
-    else {
+    } else {
       // Expected to read 2 full buffers of GetResponseBufferSize() and one
       // partial buffer.
       EXPECT_EQ(3U, filter_count_);
@@ -3695,8 +3732,9 @@ class ResponseFilterNeedMore : public ResponseFilterTestBase {
     const size_t replace_size = sizeof(kReplaceString) - 1;
 
     // Determine a reasonable amount of space for find/replace overflow.
-    if (replace_size > find_size)
+    if (replace_size > find_size) {
       replace_overflow_size_ = (replace_size - find_size) * repeat_ct_;
+    }
 
     return input;
   }
diff --git a/tests/ceftests/resource_util_linux.cc b/tests/ceftests/resource_util_linux.cc
index 6409a0d67..110d09bd6 100644
--- a/tests/ceftests/resource_util_linux.cc
+++ b/tests/ceftests/resource_util_linux.cc
@@ -16,15 +16,17 @@ bool GetResourceDir(std::string& dir) {
 
   // Retrieve the executable path.
   ssize_t len = readlink("/proc/self/exe", buff, sizeof(buff) - 1);
-  if (len == -1)
+  if (len == -1) {
     return false;
+  }
 
   buff[len] = 0;
 
   // Remove the executable name from the path.
   char* pos = strrchr(buff, '/');
-  if (!pos)
+  if (!pos) {
     return false;
+  }
 
   // Add "ceftests_files" to the path.
   strcpy(pos + 1, "ceftests_files");
diff --git a/tests/ceftests/resource_util_win_dir.cc b/tests/ceftests/resource_util_win_dir.cc
index 2bd3200f3..3df18d5e3 100644
--- a/tests/ceftests/resource_util_win_dir.cc
+++ b/tests/ceftests/resource_util_win_dir.cc
@@ -15,15 +15,17 @@ bool GetResourceDir(std::string& dir) {
 
   // Retrieve the executable path.
   auto len = GetModuleFileName(nullptr, buff, MAX_PATH);
-  if (len == 0)
+  if (len == 0) {
     return false;
+  }
 
   buff[len] = 0;
 
   // Remove the executable name from the path.
   auto* pos = wcsrchr(buff, L'\\');
-  if (!pos)
+  if (!pos) {
     return false;
+  }
 
   // Add "ceftests_files" to the path.
   wcscpy(pos + 1, L"ceftests_files");
diff --git a/tests/ceftests/resource_util_win_idmap.cc b/tests/ceftests/resource_util_win_idmap.cc
index cd54dba4e..33a684b4b 100644
--- a/tests/ceftests/resource_util_win_idmap.cc
+++ b/tests/ceftests/resource_util_win_idmap.cc
@@ -22,8 +22,9 @@ int GetResourceId(const char* resource_name) {
   };
 
   for (size_t i = 0; i < sizeof(resource_map) / sizeof(_resource_map); ++i) {
-    if (!strcmp(resource_map[i].name, resource_name))
+    if (!strcmp(resource_map[i].name, resource_name)) {
       return resource_map[i].id;
+    }
   }
 
   return 0;
diff --git a/tests/ceftests/run_all_unittests.cc b/tests/ceftests/run_all_unittests.cc
index 176970056..19bd91670 100644
--- a/tests/ceftests/run_all_unittests.cc
+++ b/tests/ceftests/run_all_unittests.cc
@@ -52,10 +52,11 @@ namespace {
 void QuitMessageLoop() {
   CEF_REQUIRE_UI_THREAD();
   client::MainMessageLoop* message_loop = client::MainMessageLoop::Get();
-  if (message_loop)
+  if (message_loop) {
     message_loop->Quit();
-  else
+  } else {
     CefQuitMessageLoop();
+  }
 }
 
 void sleep(int64 ms) {
@@ -74,8 +75,9 @@ void RunTestsOnTestThread() {
   CefTestSuite::GetInstance()->Run();
 
   // Wait for all browsers to exit.
-  while (TestHandler::HasBrowser())
+  while (TestHandler::HasBrowser()) {
     sleep(100);
+  }
 
   // Wait for the test server to stop, and then quit the CEF message loop.
   test_server::Stop(base::BindOnce(QuitMessageLoop));
@@ -131,8 +133,9 @@ int main(int argc, char* argv[]) {
   // Load the CEF framework library at runtime instead of linking directly
   // as required by the macOS sandbox implementation.
   CefScopedLibraryLoader library_loader;
-  if (!library_loader.LoadInMain())
+  if (!library_loader.LoadInMain()) {
     return 1;
+  }
 #endif
 
   // Create the singleton test suite object.
@@ -173,8 +176,9 @@ int main(int argc, char* argv[]) {
 
   // Execute the secondary process, if any.
   exit_code = CefExecuteProcess(main_args, app, windows_sandbox_info);
-  if (exit_code >= 0)
+  if (exit_code >= 0) {
     return exit_code;
+  }
 #else
   } else {
     // On OS X this executable is only used for the main process.
@@ -208,10 +212,11 @@ int main(int argc, char* argv[]) {
   // Create the MessageLoop.
   std::unique_ptr<client::MainMessageLoop> message_loop;
   if (!settings.multi_threaded_message_loop) {
-    if (settings.external_message_pump)
+    if (settings.external_message_pump) {
       message_loop = client::MainMessageLoopExternalPump::Create();
-    else
+    } else {
       message_loop.reset(new client::MainMessageLoopStd);
+    }
   }
 
   // Initialize CEF.
@@ -234,8 +239,9 @@ int main(int argc, char* argv[]) {
   } else {
     // Create and start the test thread.
     CefRefPtr<CefThread> thread = CefThread::CreateThread("test_thread");
-    if (!thread)
+    if (!thread) {
       return 1;
+    }
 
     // Start the tests from the UI thread so that any pending UI tasks get a
     // chance to execute first.
diff --git a/tests/ceftests/run_all_unittests_mac.mm b/tests/ceftests/run_all_unittests_mac.mm
index 2c8c17be1..144371a72 100644
--- a/tests/ceftests/run_all_unittests_mac.mm
+++ b/tests/ceftests/run_all_unittests_mac.mm
@@ -9,7 +9,7 @@
 static NSAutoreleasePool* g_autopool = nil;
 
 // Provide the CefAppProtocol implementation required by CEF.
-@interface TestApplication : NSApplication<CefAppProtocol> {
+@interface TestApplication : NSApplication <CefAppProtocol> {
  @private
   BOOL handlingSendEvent_;
 }
diff --git a/tests/ceftests/scheme_handler_unittest.cc b/tests/ceftests/scheme_handler_unittest.cc
index 7ae7b9a46..7d9aab398 100644
--- a/tests/ceftests/scheme_handler_unittest.cc
+++ b/tests/ceftests/scheme_handler_unittest.cc
@@ -154,8 +154,9 @@ class TestSchemeHandler : public TestHandler {
     if (IsExitURL(newUrl)) {
       test_results_->got_exit_request.yes();
       // XHR tests use an exit URL to destroy the test.
-      if (newUrl.find("SUCCESS") != std::string::npos)
+      if (newUrl.find("SUCCESS") != std::string::npos) {
         test_results_->got_sub_success.yes();
+      }
       DestroyTestIfDone();
       return RV_CANCEL;
     }
@@ -184,12 +185,13 @@ class TestSchemeHandler : public TestHandler {
                  CefRefPtr<CefFrame> frame,
                  int httpStatusCode) override {
     const std::string& url = frame->GetURL();
-    if (url == test_results_->url)
+    if (url == test_results_->url) {
       test_results_->got_output.yes();
-    else if (url == test_results_->sub_url)
+    } else if (url == test_results_->sub_url) {
       test_results_->got_sub_output.yes();
-    else if (IsExitURL(url))
+    } else if (IsExitURL(url)) {
       return;
+    }
 
     if (url == test_results_->url || test_results_->status_code != 200) {
       // Test that the status code is correct.
@@ -205,12 +207,13 @@ class TestSchemeHandler : public TestHandler {
                    const CefString& errorText,
                    const CefString& failedUrl) override {
     const std::string& url = failedUrl;
-    if (url == test_results_->url)
+    if (url == test_results_->url) {
       test_results_->got_error.yes();
-    else if (url == test_results_->sub_url)
+    } else if (url == test_results_->sub_url) {
       test_results_->got_sub_error.yes();
-    else if (IsExitURL(url))
+    } else if (IsExitURL(url)) {
       return;
+    }
 
     // Tests sometimes also fail with ERR_ABORTED or ERR_UNKNOWN_URL_SCHEME.
     if (!(test_results_->expected_error_code == 0 &&
@@ -271,15 +274,17 @@ class ClientSchemeHandlerOld : public CefResourceHandler {
     if (is_sub_) {
       test_results_->got_sub_request.yes();
 
-      if (!test_results_->sub_html.empty())
+      if (!test_results_->sub_html.empty()) {
         handled = true;
+      }
     } else {
       EXPECT_EQ(url, test_results_->url);
 
       test_results_->got_request.yes();
 
-      if (!test_results_->html.empty())
+      if (!test_results_->html.empty()) {
         handled = true;
+      }
     }
 
     std::string accept_language;
@@ -287,8 +292,9 @@ class ClientSchemeHandlerOld : public CefResourceHandler {
     CefRequest::HeaderMap::iterator headerIter;
     request->GetHeaderMap(headerMap);
     headerIter = headerMap.find("Accept-Language");
-    if (headerIter != headerMap.end())
+    if (headerIter != headerMap.end()) {
       accept_language = headerIter->second;
+    }
     EXPECT_TRUE(!accept_language.empty());
 
     if (!test_results_->accept_language.empty()) {
@@ -321,8 +327,9 @@ class ClientSchemeHandlerOld : public CefResourceHandler {
     }
 
     // Response was canceled.
-    if (g_current_handler)
+    if (g_current_handler) {
       g_current_handler->DestroyTest();
+    }
     return false;
   }
 
@@ -448,15 +455,17 @@ class ClientSchemeHandler : public CefResourceHandler {
     if (is_sub_) {
       test_results_->got_sub_request.yes();
 
-      if (!test_results_->sub_html.empty())
+      if (!test_results_->sub_html.empty()) {
         handled = true;
+      }
     } else {
       EXPECT_EQ(url, test_results_->url);
 
       test_results_->got_request.yes();
 
-      if (!test_results_->html.empty())
+      if (!test_results_->html.empty()) {
         handled = true;
+      }
     }
 
     std::string accept_language;
@@ -464,8 +473,9 @@ class ClientSchemeHandler : public CefResourceHandler {
     CefRequest::HeaderMap::iterator headerIter;
     request->GetHeaderMap(headerMap);
     headerIter = headerMap.find("Accept-Language");
-    if (headerIter != headerMap.end())
+    if (headerIter != headerMap.end()) {
       accept_language = headerIter->second;
+    }
     EXPECT_TRUE(!accept_language.empty());
 
     if (!test_results_->accept_language.empty()) {
@@ -499,8 +509,9 @@ class ClientSchemeHandler : public CefResourceHandler {
     }
 
     // Response was canceled.
-    if (g_current_handler)
+    if (g_current_handler) {
       g_current_handler->DestroyTest();
+    }
     return false;
   }
 
@@ -689,10 +700,11 @@ void SetUpXHR(const XHRTestSettings& settings) {
   g_TestResults.sub_redirect_url = settings.sub_redirect_url;
 
   std::string request_url;
-  if (!settings.sub_redirect_url.empty())
+  if (!settings.sub_redirect_url.empty()) {
     request_url = settings.sub_redirect_url;
-  else
+  } else {
     request_url = settings.sub_url;
+  }
 
   g_TestResults.url = settings.url;
   std::stringstream ss;
@@ -760,10 +772,11 @@ void SetUpFetch(const FetchTestSettings& settings) {
   g_TestResults.sub_redirect_url = settings.sub_redirect_url;
 
   std::string request_url;
-  if (!settings.sub_redirect_url.empty())
+  if (!settings.sub_redirect_url.empty()) {
     request_url = settings.sub_redirect_url;
-  else
+  } else {
     request_url = settings.sub_url;
+  }
 
   g_TestResults.url = settings.url;
   std::stringstream ss;
@@ -808,8 +821,9 @@ void SetUpXSS(const std::string& url,
 
   std::stringstream ss;
   std::string domain_line;
-  if (!domain.empty())
+  if (!domain.empty()) {
     domain_line = "document.domain = '" + domain + "';";
+  }
 
   g_TestResults.sub_url = sub_url;
   ss << "<html><head>"
diff --git a/tests/ceftests/server_unittest.cc b/tests/ceftests/server_unittest.cc
index 8ce4df3bf..e1a3a06ec 100644
--- a/tests/ceftests/server_unittest.cc
+++ b/tests/ceftests/server_unittest.cc
@@ -96,15 +96,17 @@ class TestServerHandler : public CefServerHandler {
     if (!http_request_handler_list_.empty()) {
       HttpRequestHandlerList::const_iterator it =
           http_request_handler_list_.begin();
-      for (; it != http_request_handler_list_.end(); ++it)
+      for (; it != http_request_handler_list_.end(); ++it) {
         delete *it;
+      }
     }
 
     if (!ws_request_handler_list_.empty()) {
       WsRequestHandlerList::const_iterator it =
           ws_request_handler_list_.begin();
-      for (; it != ws_request_handler_list_.end(); ++it)
+      for (; it != ws_request_handler_list_.end(); ++it) {
         delete *it;
+      }
     }
 
     std::move(destroy_callback_).Run();
@@ -165,8 +167,9 @@ class TestServerHandler : public CefServerHandler {
   // |destroy_callback|.
   void ShutdownServer() {
     EXPECT_TRUE(server_);
-    if (server_)
+    if (server_) {
       server_->Shutdown();
+    }
   }
 
   void OnServerCreated(CefRefPtr<CefServer> server) override {
@@ -224,8 +227,9 @@ class TestServerHandler : public CefServerHandler {
     connection_id_set_.erase(it);
 
     ConnectionIdSet::iterator it2 = ws_connection_id_set_.find(connection_id);
-    if (it2 != ws_connection_id_set_.end())
+    if (it2 != ws_connection_id_set_.end()) {
       ws_connection_id_set_.erase(it2);
+    }
 
     if (connection_id_set_.empty()) {
       EXPECT_TRUE(ws_connection_id_set_.empty());
@@ -248,8 +252,9 @@ class TestServerHandler : public CefServerHandler {
     for (; it != http_request_handler_list_.end(); ++it) {
       handled =
           (*it)->HandleRequest(server, connection_id, client_address, request);
-      if (handled)
+      if (handled) {
         break;
+      }
     }
     EXPECT_TRUE(handled) << "missing HttpRequestHandler for "
                          << request->GetURL().ToString();
@@ -276,8 +281,9 @@ class TestServerHandler : public CefServerHandler {
     for (; it != ws_request_handler_list_.end(); ++it) {
       handled = (*it)->HandleRequest(server, connection_id, client_address,
                                      request, callback);
-      if (handled)
+      if (handled) {
         break;
+      }
     }
     EXPECT_TRUE(handled) << "missing WsRequestHandler for "
                          << request->GetURL().ToString();
@@ -297,8 +303,9 @@ class TestServerHandler : public CefServerHandler {
     WsRequestHandlerList::const_iterator it = ws_request_handler_list_.begin();
     for (; it != ws_request_handler_list_.end(); ++it) {
       handled = (*it)->HandleConnected(server, connection_id);
-      if (handled)
+      if (handled) {
         break;
+      }
     }
     EXPECT_TRUE(handled) << "missing WsRequestHandler for " << connection_id;
 
@@ -321,8 +328,9 @@ class TestServerHandler : public CefServerHandler {
     WsRequestHandlerList::const_iterator it = ws_request_handler_list_.begin();
     for (; it != ws_request_handler_list_.end(); ++it) {
       handled = (*it)->HandleMessage(server, connection_id, data, data_size);
-      if (handled)
+      if (handled) {
         break;
+      }
     }
     EXPECT_TRUE(handled) << "missing WsRequestHandler for " << connection_id;
 
@@ -497,8 +505,9 @@ class HttpTestRunner : public base::RefCountedThreadSafe<HttpTestRunner> {
         next_request_id_(0) {}
 
   virtual ~HttpTestRunner() {
-    if (destroy_event_)
+    if (destroy_event_) {
       destroy_event_->Signal();
+    }
   }
 
   void AddRequestRunner(std::unique_ptr<RequestRunner> request_runner) {
@@ -624,8 +633,9 @@ class HttpTestRunner : public base::RefCountedThreadSafe<HttpTestRunner> {
     EXPECT_TRUE(request_runner_map_.empty());
 
     // Cancel the timeout, if any.
-    if (ui_thread_helper_)
+    if (ui_thread_helper_) {
       ui_thread_helper_.reset();
+    }
 
     // Signal test completion.
     run_event_->Signal();
@@ -633,8 +643,9 @@ class HttpTestRunner : public base::RefCountedThreadSafe<HttpTestRunner> {
 
   TestHandler::UIThreadHelper* GetUIThreadHelper() {
     EXPECT_UI_THREAD();
-    if (!ui_thread_helper_)
+    if (!ui_thread_helper_) {
       ui_thread_helper_.reset(new TestHandler::UIThreadHelper());
+    }
     return ui_thread_helper_.get();
   }
 
@@ -749,8 +760,9 @@ void SendHttpServerResponse(CefRefPtr<CefServer> server,
 std::string GetHeaderValue(const CefServer::HeaderMap& header_map,
                            const std::string& header_name) {
   CefServer::HeaderMap::const_iterator it = header_map.find(header_name);
-  if (it != header_map.end())
+  if (it != header_map.end()) {
     return it->second;
+  }
   return std::string();
 }
 
@@ -811,8 +823,9 @@ CefRefPtr<CefRequest> CreateTestServerRequest(
     header_map.insert(std::make_pair("content-type", content_type));
   }
 
-  if (!extra_headers.empty())
+  if (!extra_headers.empty()) {
     header_map.insert(extra_headers.begin(), extra_headers.end());
+  }
   request->SetHeaderMap(header_map);
 
   return request;
@@ -936,8 +949,9 @@ class StaticHttpRequestRunner : public HttpTestRunner::RequestRunner {
     CefRefPtr<CefRequest> request = CreateTestServerRequest(path, "GET");
     HttpServerResponse response(HttpServerResponse::TYPE_200);
     response.content_type = "text/html";
-    if (with_content)
+    if (with_content) {
       response.content = "<html>200 response content</html>";
+    }
     return std::make_unique<StaticHttpRequestRunner>(request, response);
   }
 
@@ -972,10 +986,12 @@ class StaticHttpRequestRunner : public HttpTestRunner::RequestRunner {
 
     HttpServerResponse response(HttpServerResponse::TYPE_CUSTOM);
     response.response_code = 202;
-    if (with_content)
+    if (with_content) {
       response.content = "BlahBlahBlah";
-    if (!with_content_length)
+    }
+    if (!with_content_length) {
       response.no_content_length = true;
+    }
     response.content_type = "application/x-blah-blah";
     response.extra_headers.insert(
         std::make_pair("x-response-custom1", "My Value 1"));
@@ -1028,8 +1044,9 @@ class StaticHttpRequestRunner : public HttpTestRunner::RequestRunner {
 
     EXPECT_EQ(error, ERR_NONE)
         << "OnResponseComplete for " << request_->GetURL().ToString();
-    if (error == ERR_NONE)
+    if (error == ERR_NONE) {
       VerifyHttpServerResponse(response_, response, data);
+    }
 
     std::move(complete_callback_).Run();
   }
diff --git a/tests/ceftests/stream_resource_handler_unittest.cc b/tests/ceftests/stream_resource_handler_unittest.cc
index 98f3f30c5..0c83d3c27 100644
--- a/tests/ceftests/stream_resource_handler_unittest.cc
+++ b/tests/ceftests/stream_resource_handler_unittest.cc
@@ -143,8 +143,9 @@ class ReadTestHandler : public RoutingTestHandler {
 
  private:
   void DestroyTestIfDone() {
-    if (got_on_query_ && got_on_loading_state_change_done_)
+    if (got_on_query_ && got_on_loading_state_change_done_) {
       DestroyTest();
+    }
   }
 
   void DestroyTest() override {
diff --git a/tests/ceftests/string_unittest.cc b/tests/ceftests/string_unittest.cc
index 11a50659b..3e77616b0 100644
--- a/tests/ceftests/string_unittest.cc
+++ b/tests/ceftests/string_unittest.cc
@@ -163,8 +163,9 @@ TEST(StringTest, List) {
   cef_string_list_t listPtr = cef_string_list_alloc();
   EXPECT_TRUE(listPtr != nullptr);
   ListType::const_iterator it = list.begin();
-  for (; it != list.end(); ++it)
+  for (; it != list.end(); ++it) {
     cef_string_list_append(listPtr, it->GetStruct());
+  }
 
   CefString str;
   int ret;
diff --git a/tests/ceftests/test_handler.cc b/tests/ceftests/test_handler.cc
index ad1005458..4bf9c0147 100644
--- a/tests/ceftests/test_handler.cc
+++ b/tests/ceftests/test_handler.cc
@@ -45,8 +45,9 @@ class TestWindowDelegate : public CefWindowDelegate {
   bool CanClose(CefRefPtr<CefWindow> window) override {
     // Allow the window to close if the browser says it's OK.
     CefRefPtr<CefBrowser> browser = browser_view_->GetBrowser();
-    if (browser)
+    if (browser) {
       return browser->GetHost()->TryCloseBrowser();
+    }
     return true;
   }
 
@@ -128,14 +129,16 @@ void TestHandler::Collection::ExecuteTests() {
   TestHandlerList::const_iterator it;
 
   it = handler_list_.begin();
-  for (; it != handler_list_.end(); ++it)
+  for (; it != handler_list_.end(); ++it) {
     (*it)->SetupTest();
+  }
 
   completion_state_->WaitForTests();
 
   it = handler_list_.begin();
-  for (; it != handler_list_.end(); ++it)
+  for (; it != handler_list_.end(); ++it) {
     (*it)->RunTest();
+  }
 
   completion_state_->WaitForTests();
 }
@@ -187,17 +190,20 @@ TestHandler::TestHandler(CompletionState* completion_state)
 
 TestHandler::~TestHandler() {
   DCHECK(!ui_thread_helper_.get());
-  if (destroy_test_expected_)
+  if (destroy_test_expected_) {
     EXPECT_TRUE(destroy_test_called_);
-  else
+  } else {
     EXPECT_FALSE(destroy_test_called_);
+  }
   EXPECT_TRUE(browser_map_.empty());
 
-  if (completion_state_owned_)
+  if (completion_state_owned_) {
     delete completion_state_;
+  }
 
-  if (destroy_event_)
+  if (destroy_event_) {
     destroy_event_->Signal();
+  }
 }
 
 void TestHandler::OnAfterCreated(CefRefPtr<CefBrowser> browser) {
@@ -296,8 +302,9 @@ void TestHandler::ExecuteTest() {
   EXPECT_EQ(completion_state_->total(), 1);
 
   // Reset any state from the previous run.
-  if (destroy_test_called_)
+  if (destroy_test_called_) {
     destroy_test_called_ = false;
+  }
 
   // Run the test.
   RunTest();
@@ -318,8 +325,9 @@ void TestHandler::DestroyTest() {
   }
 
   EXPECT_TRUE(destroy_test_expected_);
-  if (destroy_test_called_)
+  if (destroy_test_called_) {
     return;
+  }
   destroy_test_called_ = true;
 
   if (!browser_map_.empty()) {
@@ -329,12 +337,14 @@ void TestHandler::DestroyTest() {
 
     // Tell all browsers to close.
     BrowserMap::const_iterator it = browser_map.begin();
-    for (; it != browser_map.end(); ++it)
+    for (; it != browser_map.end(); ++it) {
       CloseBrowser(it->second, false);
+    }
   }
 
-  if (ui_thread_helper_.get())
+  if (ui_thread_helper_.get()) {
     ui_thread_helper_.reset(nullptr);
+  }
 }
 
 void TestHandler::OnTestTimeout(int timeout_ms, bool treat_as_error) {
@@ -404,8 +414,9 @@ void TestHandler::AddResourceEx(const std::string& url,
   // Ignore the query component, if any.
   std::string urlStr = url;
   size_t idx = urlStr.find('?');
-  if (idx > 0)
+  if (idx > 0) {
     urlStr = urlStr.substr(0, idx);
+  }
 
   resource_map_.insert(std::make_pair(urlStr, content));
 }
@@ -458,8 +469,9 @@ TestHandler::UIThreadHelper* TestHandler::GetUIThreadHelper() {
   EXPECT_UI_THREAD();
   CHECK(!destroy_test_called_);
 
-  if (!ui_thread_helper_.get())
+  if (!ui_thread_helper_.get()) {
     ui_thread_helper_.reset(new UIThreadHelper());
+  }
   return ui_thread_helper_.get();
 }
 
diff --git a/tests/ceftests/test_request.cc b/tests/ceftests/test_request.cc
index 0a92131df..440137e50 100644
--- a/tests/ceftests/test_request.cc
+++ b/tests/ceftests/test_request.cc
@@ -117,8 +117,9 @@ class CookieVisitor : public CefCookieVisitor {
              bool& deleteCookie) override {
     CEF_REQUIRE_UI_THREAD();
     cookies_.push_back(cookie);
-    if (delete_cookies_)
+    if (delete_cookies_) {
       deleteCookie = true;
+    }
     return true;
   }
 
diff --git a/tests/ceftests/test_server.cc b/tests/ceftests/test_server.cc
index 3de93cd6f..855e2cf6c 100644
--- a/tests/ceftests/test_server.cc
+++ b/tests/ceftests/test_server.cc
@@ -47,8 +47,9 @@ std::string GetHost(bool https_server, bool include_port) {
 
   const auto scheme_offset = origin.find("//");
   const auto& origin_without_scheme = origin.substr(scheme_offset + 2);
-  if (include_port)
+  if (include_port) {
     return origin_without_scheme;
+  }
 
   const auto port_offset = origin_without_scheme.find(':');
   return origin_without_scheme.substr(0, port_offset);
diff --git a/tests/ceftests/test_server_manager.cc b/tests/ceftests/test_server_manager.cc
index 38489b792..df6d96f3b 100644
--- a/tests/ceftests/test_server_manager.cc
+++ b/tests/ceftests/test_server_manager.cc
@@ -52,8 +52,9 @@ class ObserverRegistration : public CefRegistration {
     }
 
     registration->Initialize();
-    if (!callback.is_null())
+    if (!callback.is_null()) {
       std::move(callback).Run();
+    }
   }
 
  private:
diff --git a/tests/ceftests/test_server_observer_unittest.cc b/tests/ceftests/test_server_observer_unittest.cc
index 315844b07..b1fd4996e 100644
--- a/tests/ceftests/test_server_observer_unittest.cc
+++ b/tests/ceftests/test_server_observer_unittest.cc
@@ -76,8 +76,9 @@ class TestServerObserver : public test_server::ObserverHelper {
                            const ResponseCallback& response_callback) override {
     CEF_REQUIRE_UI_THREAD();
     const std::string& url = request->GetURL();
-    if (url != url_)
+    if (url != url_) {
       return false;
+    }
 
     EXPECT_TRUE(state_->got_initialized_);
     EXPECT_FALSE(state_->got_request_);
diff --git a/tests/ceftests/test_server_unittest.cc b/tests/ceftests/test_server_unittest.cc
index a58ccf48d..9e9da9d28 100644
--- a/tests/ceftests/test_server_unittest.cc
+++ b/tests/ceftests/test_server_unittest.cc
@@ -114,8 +114,9 @@ class TestServerHandler : public CefTestServerHandler {
     bool handled = false;
     for (const auto& handler : http_request_handler_list_) {
       handled = handler->HandleRequest(server, request, connection);
-      if (handled)
+      if (handled) {
         break;
+      }
     }
     EXPECT_TRUE(handled) << "missing HttpRequestHandler for "
                          << request->GetURL().ToString();
@@ -225,8 +226,9 @@ class HttpTestRunner : public base::RefCountedThreadSafe<HttpTestRunner> {
       : https_server_(https_server), parallel_requests_(parallel_requests) {}
 
   virtual ~HttpTestRunner() {
-    if (destroy_event_)
+    if (destroy_event_) {
       destroy_event_->Signal();
+    }
   }
 
   void AddRequestRunner(std::unique_ptr<RequestRunner> request_runner) {
@@ -353,8 +355,9 @@ class HttpTestRunner : public base::RefCountedThreadSafe<HttpTestRunner> {
     EXPECT_TRUE(request_runner_map_.empty());
 
     // Cancel the timeout, if any.
-    if (ui_thread_helper_)
+    if (ui_thread_helper_) {
       ui_thread_helper_.reset();
+    }
 
     // Signal test completion.
     run_event_->Signal();
@@ -362,8 +365,9 @@ class HttpTestRunner : public base::RefCountedThreadSafe<HttpTestRunner> {
 
   TestHandler::UIThreadHelper* GetUIThreadHelper() {
     EXPECT_UI_THREAD();
-    if (!ui_thread_helper_)
+    if (!ui_thread_helper_) {
       ui_thread_helper_.reset(new TestHandler::UIThreadHelper());
+    }
     return ui_thread_helper_.get();
   }
 
@@ -461,8 +465,9 @@ void SendHttpServerResponse(CefRefPtr<CefTestServerConnection> connection,
 std::string GetHeaderValue(const CefRequest::HeaderMap& header_map,
                            const std::string& header_name) {
   CefRequest::HeaderMap::const_iterator it = header_map.find(header_name);
-  if (it != header_map.end())
+  if (it != header_map.end()) {
     return it->second;
+  }
   return std::string();
 }
 
@@ -521,8 +526,9 @@ CefRefPtr<CefRequest> CreateTestServerRequest(
     header_map.insert(std::make_pair("content-type", content_type));
   }
 
-  if (!extra_headers.empty())
+  if (!extra_headers.empty()) {
     header_map.insert(extra_headers.begin(), extra_headers.end());
+  }
   request->SetHeaderMap(header_map);
 
   return request;
@@ -645,8 +651,9 @@ class StaticHttpRequestRunner : public HttpTestRunner::RequestRunner {
     CefRefPtr<CefRequest> request = CreateTestServerRequest(path, "GET");
     HttpServerResponse response(HttpServerResponse::TYPE_200);
     response.content_type = "text/html";
-    if (with_content)
+    if (with_content) {
       response.content = "<html>200 response content</html>";
+    }
     return std::make_unique<StaticHttpRequestRunner>(request, response);
   }
 
@@ -680,8 +687,9 @@ class StaticHttpRequestRunner : public HttpTestRunner::RequestRunner {
 
     HttpServerResponse response(HttpServerResponse::TYPE_CUSTOM);
     response.response_code = 202;
-    if (with_content)
+    if (with_content) {
       response.content = "BlahBlahBlah";
+    }
     response.content_type = "application/x-blah-blah";
     response.extra_headers.insert(
         std::make_pair("x-response-custom1", "My Value 1"));
@@ -742,8 +750,9 @@ class StaticHttpRequestRunner : public HttpTestRunner::RequestRunner {
 
     EXPECT_EQ(error, ERR_NONE)
         << "OnResponseComplete for " << request_->GetURL().ToString();
-    if (error == ERR_NONE)
+    if (error == ERR_NONE) {
       VerifyHttpServerResponse(response_, response, data);
+    }
 
     std::move(complete_callback_).Run();
   }
diff --git a/tests/ceftests/test_suite.cc b/tests/ceftests/test_suite.cc
index 9c7354200..d7cf1b4d4 100644
--- a/tests/ceftests/test_suite.cc
+++ b/tests/ceftests/test_suite.cc
@@ -43,12 +43,14 @@ void RouteStdioToConsole(bool create_console_if_not_found) {
   if (!AttachConsole(ATTACH_PARENT_PROCESS)) {
     unsigned int result = GetLastError();
     // Was probably already attached.
-    if (result == ERROR_ACCESS_DENIED)
+    if (result == ERROR_ACCESS_DENIED) {
       return;
+    }
     // Don't bother creating a new console for each child process if the
     // parent process is invalid (eg: crashed).
-    if (result == ERROR_GEN_FAILURE)
+    if (result == ERROR_GEN_FAILURE) {
       return;
+    }
     if (create_console_if_not_found) {
       // Make a new console if attaching to parent fails with any other error.
       // It should be ERROR_INVALID_HANDLE at this point, which means the
@@ -156,8 +158,9 @@ void CefTestSuite::GetSettings(CefSettings& settings) const {
   // Value of kJavascriptFlags switch.
   std::string other_javascript_flags =
       command_line_->GetSwitchValue("js-flags");
-  if (!other_javascript_flags.empty())
+  if (!other_javascript_flags.empty()) {
     javascript_flags += " " + other_javascript_flags;
+  }
   CefString(&settings.javascript_flags) = javascript_flags;
 
   // Necessary for V8Test.OnUncaughtException tests.
diff --git a/tests/ceftests/test_util.cc b/tests/ceftests/test_util.cc
index 7eb3b4f87..35c0b5d58 100644
--- a/tests/ceftests/test_util.cc
+++ b/tests/ceftests/test_util.cc
@@ -91,8 +91,9 @@ void TestPostDataEqual(CefRefPtr<CefPostData> postData1,
 
   CefPostData::ElementVector::const_iterator it1 = ev1.begin();
   CefPostData::ElementVector::const_iterator it2 = ev2.begin();
-  for (; it1 != ev1.end() && it2 != ev2.end(); ++it1, ++it2)
+  for (; it1 != ev1.end() && it2 != ev2.end(); ++it1, ++it2) {
     TestPostDataElementEqual((*it1), (*it2));
+  }
 }
 
 void TestRequestEqual(CefRefPtr<CefRequest> request1,
@@ -118,8 +119,9 @@ void TestRequestEqual(CefRefPtr<CefRequest> request1,
   CefRefPtr<CefPostData> postData1 = request1->GetPostData();
   CefRefPtr<CefPostData> postData2 = request2->GetPostData();
   EXPECT_EQ(!!(postData1.get()), !!(postData2.get()));
-  if (postData1.get() && postData2.get())
+  if (postData1.get() && postData2.get()) {
     TestPostDataEqual(postData1, postData2);
+  }
 }
 
 void TestResponseEqual(CefRefPtr<CefResponse> response1,
@@ -270,8 +272,9 @@ void TestStringVectorEqual(const std::vector<CefString>& val1,
                            const std::vector<CefString>& val2) {
   EXPECT_EQ(val1.size(), val2.size());
 
-  for (size_t i = 0; i < val1.size(); ++i)
+  for (size_t i = 0; i < val1.size(); ++i) {
     EXPECT_STREQ(val1[i].ToString().c_str(), val2[i].ToString().c_str());
+  }
 }
 
 bool TestOldResourceAPI() {
@@ -296,8 +299,9 @@ bool IsChromeRuntimeEnabled() {
 
 bool IsBFCacheEnabled() {
   // Supported by the Chrome runtime only, see issue #3237.
-  if (!IsChromeRuntimeEnabled())
+  if (!IsChromeRuntimeEnabled()) {
     return false;
+  }
 
   // Enabled by default starting in M96.
   static int state = -1;
@@ -327,10 +331,12 @@ CefRefPtr<CefRequestContext> CreateTestRequestContext(
   EXPECT_TRUE(cache_path.empty() || mode == TEST_RC_MODE_CUSTOM ||
               mode == TEST_RC_MODE_CUSTOM_WITH_HANDLER);
 
-  if (mode == TEST_RC_MODE_NONE)
+  if (mode == TEST_RC_MODE_NONE) {
     return nullptr;
-  if (mode == TEST_RC_MODE_GLOBAL)
+  }
+  if (mode == TEST_RC_MODE_GLOBAL) {
     return CefRequestContext::GetGlobalContext();
+  }
 
   CefRefPtr<CefRequestContextHandler> rc_handler;
   if (mode == TEST_RC_MODE_GLOBAL_WITH_HANDLER ||
@@ -347,8 +353,9 @@ CefRefPtr<CefRequestContext> CreateTestRequestContext(
 
   if (mode == TEST_RC_MODE_CUSTOM || mode == TEST_RC_MODE_CUSTOM_WITH_HANDLER) {
     CefRequestContextSettings settings;
-    if (!cache_path.empty())
+    if (!cache_path.empty()) {
       CefString(&settings.cache_path) = cache_path;
+    }
     return CefRequestContext::CreateContext(settings, rc_handler);
   }
 
diff --git a/tests/ceftests/thread_unittest.cc b/tests/ceftests/thread_unittest.cc
index cef547373..f5152a201 100644
--- a/tests/ceftests/thread_unittest.cc
+++ b/tests/ceftests/thread_unittest.cc
@@ -163,14 +163,17 @@ class SimpleThreadTest : public ThreadTest {
   void Task() {
     AssertTestThread();
     got_task_count_++;
-    if (!task_callback_.is_null())
+    if (!task_callback_.is_null()) {
       std::move(task_callback_).Run();
+    }
   }
 
   void Done() {
     AssertOwnerThread();
-    if (++got_done_count_ == expected_task_count_ && !done_callback_.is_null())
+    if (++got_done_count_ == expected_task_count_ &&
+        !done_callback_.is_null()) {
       std::move(done_callback_).Run();
+    }
   }
 
   const size_t expected_task_count_;
@@ -247,8 +250,9 @@ class BrowserThreadTestHandler : public TestHandler {
                             bool isLoading,
                             bool canGoBack,
                             bool canGoForward) override {
-    if (!isLoading)
+    if (!isLoading) {
       RunThreadTestOnOwnerThread();
+    }
   }
 
  private:
@@ -344,8 +348,9 @@ class RenderThreadTestHandler : public TestHandler {
 
     got_message_.yes();
 
-    if (message->GetArgumentList()->GetBool(0))
+    if (message->GetArgumentList()->GetBool(0)) {
       got_success_.yes();
+    }
 
     // Test is complete.
     DestroyTest();
diff --git a/tests/ceftests/urlrequest_unittest.cc b/tests/ceftests/urlrequest_unittest.cc
index bd5998468..89bbf90ce 100644
--- a/tests/ceftests/urlrequest_unittest.cc
+++ b/tests/ceftests/urlrequest_unittest.cc
@@ -455,8 +455,9 @@ std::string GetHeaderValue(const CefRequest::HeaderMap& header_map,
   CefRequest::HeaderMap::const_iterator it = header_map.begin();
   for (; it != header_map.end(); ++it) {
     std::string name = client::AsciiStrToLower(it->first);
-    if (name == header_name_lower)
+    if (name == header_name_lower) {
       return it->second;
+    }
   }
   return std::string();
 }
@@ -504,8 +505,9 @@ void VerifyNormalRequest(const RequestRunSettings* settings,
 void GetNormalResponse(const RequestRunSettings* settings,
                        CefRefPtr<CefResponse> response) {
   EXPECT_TRUE(settings->response);
-  if (!settings->response)
+  if (!settings->response) {
     return;
+  }
 
   response->SetStatus(settings->response->GetStatus());
   response->SetStatusText(settings->response->GetStatusText());
@@ -540,8 +542,9 @@ bool IsAuthorized(CefRefPtr<CefRequest> request,
                   const std::string& username,
                   const std::string& password) {
   const std::string& authHeader = request->GetHeaderByName("Authorization");
-  if (authHeader.empty())
+  if (authHeader.empty()) {
     return false;
+  }
 
   if (authHeader.find("Basic ") == 0) {
     const std::string& base64 = authHeader.substr(6);
@@ -586,8 +589,9 @@ class RequestSchemeHandlerOld : public CefResourceHandler {
 
     // HEAD requests are identical to GET requests except no response data is
     // sent.
-    if (request->GetMethod() != "HEAD")
+    if (request->GetMethod() != "HEAD") {
       response_data_ = settings_->response_data;
+    }
 
     // Continue immediately.
     callback->Continue();
@@ -663,8 +667,9 @@ class RequestSchemeHandler : public CefResourceHandler {
 
     // HEAD requests are identical to GET requests except no response data is
     // sent.
-    if (request->GetMethod() != "HEAD")
+    if (request->GetMethod() != "HEAD") {
       response_data_ = settings_->response_data;
+    }
 
     // Continue immediately.
     handle_request = true;
@@ -2311,10 +2316,11 @@ class RequestTestRunner : public base::RefCountedThreadSafe<RequestTestRunner> {
 
     test_request::SendConfig config;
 
-    if (settings_.redirect_request)
+    if (settings_.redirect_request) {
       config.request_ = settings_.redirect_request;
-    else
+    } else {
       config.request_ = settings_.request;
+    }
     EXPECT_TRUE(config.request_.get());
 
     // Not delegating to CefRequestHandler::GetAuthCredentials.
@@ -2343,10 +2349,11 @@ class RequestTestRunner : public base::RefCountedThreadSafe<RequestTestRunner> {
     CefRefPtr<CefRequest> expected_request;
     CefRefPtr<CefResponse> expected_response;
 
-    if (settings_.redirect_request)
+    if (settings_.redirect_request) {
       expected_request = settings_.redirect_request;
-    else
+    } else {
       expected_request = settings_.request;
+    }
 
     if (settings_.redirect_response && !settings_.expect_follow_redirect) {
       // A redirect response was sent but the redirect is not expected to be
@@ -2360,8 +2367,9 @@ class RequestTestRunner : public base::RefCountedThreadSafe<RequestTestRunner> {
 
     EXPECT_EQ(settings_.expected_status, client->status_);
     EXPECT_EQ(settings_.expected_error_code, client->error_code_);
-    if (expected_response && client->response_)
+    if (expected_response && client->response_) {
       TestResponseEqual(expected_response, client->response_, true);
+    }
 
     EXPECT_EQ(settings_.expect_response_was_cached,
               client->response_was_cached_);
@@ -2638,8 +2646,9 @@ class RequestRendererTest : public ClientAppRenderer::Delegate {
       CefRefPtr<CefListValue> args = message->GetArgumentList();
 
       const bool use_frame_method = args->GetBool(2);
-      if (use_frame_method)
+      if (use_frame_method) {
         frame_ = frame;
+      }
 
       test_mode_ = static_cast<RequestTestMode>(args->GetInt(0));
       test_runner_ = new RequestTestRunner(
@@ -2925,8 +2934,9 @@ class RequestTestHandler : public TestHandler {
       EXPECT_TRUE(args->SetBool(1, test_server_backend_));
       EXPECT_TRUE(args->SetBool(2, test_frame_method_));
 
-      if (test_frame_method_)
+      if (test_frame_method_) {
         test_frame_ = frame;
+      }
       test_running_ = true;
 
       // Send a message to the renderer process to run the test.
@@ -2948,8 +2958,9 @@ class RequestTestHandler : public TestHandler {
     EXPECT_FALSE(got_message_);
     got_message_.yes();
 
-    if (message->GetArgumentList()->GetBool(0))
+    if (message->GetArgumentList()->GetBool(0)) {
       got_success_.yes();
+    }
 
     const std::string& message_name = message->GetName();
     if (message_name == kRequestTestMsg) {
@@ -3071,8 +3082,9 @@ class RequestTestHandler : public TestHandler {
     // Release references to the context and handler.
     test_runner_->Destroy();
 
-    if (call_test_complete)
+    if (call_test_complete) {
       OnTestComplete();
+    }
   }
 
   void OnTestComplete() {
diff --git a/tests/ceftests/v8_unittest.cc b/tests/ceftests/v8_unittest.cc
index ff2cd012b..7d883c54a 100644
--- a/tests/ceftests/v8_unittest.cc
+++ b/tests/ceftests/v8_unittest.cc
@@ -645,8 +645,9 @@ class V8RendererTest : public ClientAppRenderer::Delegate,
     CefRefPtr<CefV8Value> retval;
     CefRefPtr<CefV8Exception> exception;
     EXPECT_TRUE(context->Eval(test, CefString(), 0, retval, exception));
-    if (exception.get())
+    if (exception.get()) {
       ADD_FAILURE() << exception->GetMessage().c_str();
+    }
 
     EXPECT_TRUE(static_data[0] == 19);
     EXPECT_TRUE(value->GetArrayBufferReleaseCallback().get() != nullptr);
@@ -1644,8 +1645,9 @@ class V8RendererTest : public ClientAppRenderer::Delegate,
     CefRefPtr<CefV8Exception> exception;
 
     EXPECT_TRUE(context->Eval(test.str(), CefString(), 0, retval, exception));
-    if (exception.get())
+    if (exception.get()) {
       ADD_FAILURE() << exception->GetMessage().c_str();
+    }
 
     CefRefPtr<CefV8Value> newval = object->GetValue(kName);
     EXPECT_TRUE(newval.get());
@@ -1682,8 +1684,9 @@ class V8RendererTest : public ClientAppRenderer::Delegate,
     CefRefPtr<CefV8Exception> exception;
 
     EXPECT_TRUE(context->Eval(test.str(), CefString(), 0, retval, exception));
-    if (exception.get())
+    if (exception.get()) {
       ADD_FAILURE() << exception->GetMessage().c_str();
+    }
 
     CefRefPtr<CefV8Value> newval = object->GetValue(kName);
     EXPECT_TRUE(newval.get());
@@ -1726,8 +1729,9 @@ class V8RendererTest : public ClientAppRenderer::Delegate,
     CefRefPtr<CefV8Exception> exception;
 
     EXPECT_TRUE(context->Eval(test.str(), CefString(), 0, retval, exception));
-    if (exception.get())
+    if (exception.get()) {
       ADD_FAILURE() << exception->GetMessage().c_str();
+    }
 
     CefRefPtr<CefV8Value> newval = obj1->GetValue(kArgName);
     EXPECT_TRUE(newval.get());
@@ -1770,8 +1774,9 @@ class V8RendererTest : public ClientAppRenderer::Delegate,
     CefRefPtr<CefV8Exception> exception;
 
     EXPECT_TRUE(context->Eval(test.str(), CefString(), 0, retval, exception));
-    if (exception.get())
+    if (exception.get()) {
       ADD_FAILURE() << exception->GetMessage().c_str();
+    }
 
     CefRefPtr<CefV8Value> newval = obj1->GetValue(kArgName);
     EXPECT_TRUE(newval.get());
@@ -1811,8 +1816,9 @@ class V8RendererTest : public ClientAppRenderer::Delegate,
     CefRefPtr<CefV8Exception> exception;
 
     EXPECT_TRUE(context->Eval(test.str(), CefString(), 0, retval, exception));
-    if (exception.get())
+    if (exception.get()) {
       ADD_FAILURE() << exception->GetMessage().c_str();
+    }
 
     CefRefPtr<CefV8Value> newval = object->GetValue(kName);
     EXPECT_TRUE(newval.get());
@@ -1852,8 +1858,9 @@ class V8RendererTest : public ClientAppRenderer::Delegate,
     CefRefPtr<CefV8Exception> exception;
 
     EXPECT_TRUE(context->Eval(test.str(), CefString(), 0, retval, exception));
-    if (exception.get())
+    if (exception.get()) {
       ADD_FAILURE() << exception->GetMessage().c_str();
+    }
 
     CefRefPtr<CefV8Value> newval = object->GetValue(kName);
     EXPECT_TRUE(newval.get());
@@ -2593,8 +2600,9 @@ class V8RendererTest : public ClientAppRenderer::Delegate,
     EXPECT_TRUE(context->Eval(
         "document.getElementById('f').contentWindow.v8_context_entered_test()",
         CefString(), 0, retval, exception));
-    if (exception.get())
+    if (exception.get()) {
       ADD_FAILURE() << exception->GetMessage().c_str();
+    }
 
     EXPECT_TRUE(retval.get());
     EXPECT_TRUE(retval->IsInt());
@@ -2748,8 +2756,9 @@ class V8RendererTest : public ClientAppRenderer::Delegate,
     if (extra_info && extra_info->HasKey(kV8TestCmdKey)) {
       test_mode_ = static_cast<V8TestMode>(extra_info->GetInt(kV8TestCmdKey));
     }
-    if (test_mode_ > V8TEST_NONE)
+    if (test_mode_ > V8TEST_NONE) {
       RunStartupTest();
+    }
     if (test_mode_ == V8TEST_CONTEXT_EVAL_CSP_BYPASS_UNSAFE_EVAL ||
         test_mode_ == V8TEST_CONTEXT_EVAL_CSP_BYPASS_SANDBOX) {
       browser_ = browser;
@@ -2758,8 +2767,9 @@ class V8RendererTest : public ClientAppRenderer::Delegate,
 
   CefRefPtr<CefLoadHandler> GetLoadHandler(
       CefRefPtr<ClientAppRenderer> app) override {
-    if (test_mode_ == V8TEST_NONE)
+    if (test_mode_ == V8TEST_NONE) {
       return nullptr;
+    }
 
     return this;
   }
@@ -2777,8 +2787,9 @@ class V8RendererTest : public ClientAppRenderer::Delegate,
                         CefRefPtr<CefBrowser> browser,
                         CefRefPtr<CefFrame> frame,
                         CefRefPtr<CefV8Context> context) override {
-    if (test_mode_ == V8TEST_NONE)
+    if (test_mode_ == V8TEST_NONE) {
       return;
+    }
 
     if (test_mode_ == V8TEST_ON_UNCAUGHT_EXCEPTION_DEV_TOOLS) {
       if (!browser->IsPopup()) {
@@ -2927,8 +2938,9 @@ class V8RendererTest : public ClientAppRenderer::Delegate,
                            CefRefPtr<CefV8Context> context,
                            CefRefPtr<CefV8Exception> exception,
                            CefRefPtr<CefV8StackTrace> stackTrace) override {
-    if (test_mode_ == V8TEST_NONE)
+    if (test_mode_ == V8TEST_NONE) {
       return;
+    }
 
     if (test_mode_ == V8TEST_ON_UNCAUGHT_EXCEPTION ||
         test_mode_ == V8TEST_ON_UNCAUGHT_EXCEPTION_DEV_TOOLS) {
@@ -2957,8 +2969,9 @@ class V8RendererTest : public ClientAppRenderer::Delegate,
                                 CefRefPtr<CefFrame> frame,
                                 CefProcessId source_process,
                                 CefRefPtr<CefProcessMessage> message) override {
-    if (test_mode_ == V8TEST_NONE)
+    if (test_mode_ == V8TEST_NONE) {
       return false;
+    }
 
     const std::string& message_name = message->GetName();
     if (message_name == kV8RunTestMsg) {
@@ -3258,8 +3271,9 @@ class V8TestHandler : public TestHandler {
 
     got_message_.yes();
 
-    if (message->GetArgumentList()->GetBool(0))
+    if (message->GetArgumentList()->GetBool(0)) {
       got_success_.yes();
+    }
 
     // Test is complete.
     DestroyTest();
diff --git a/tests/ceftests/views/button_unittest.cc b/tests/ceftests/views/button_unittest.cc
index 6afc6f8d3..5c0c73b6e 100644
--- a/tests/ceftests/views/button_unittest.cc
+++ b/tests/ceftests/views/button_unittest.cc
@@ -213,13 +213,15 @@ void RunLabelButtonClick(bool with_text,
   EXPECT_TRUE(button->IsVisible());
   EXPECT_FALSE(button->IsDrawn());
 
-  if (with_text)
+  if (with_text) {
     EXPECT_STREQ(kButtonText, button->GetText().ToString().c_str());
-  else
+  } else {
     EXPECT_TRUE(button->GetText().empty());
+  }
 
-  if (with_image)
+  if (with_image) {
     AddImage(button);
+  }
 
   window->AddChildView(button);
   window->Layout();
@@ -449,13 +451,15 @@ void RunMenuButtonClick(bool with_text,
   EXPECT_TRUE(button->IsVisible());
   EXPECT_FALSE(button->IsDrawn());
 
-  if (with_text)
+  if (with_text) {
     EXPECT_STREQ(kButtonText, button->GetText().ToString().c_str());
-  else
+  } else {
     EXPECT_TRUE(button->GetText().empty());
+  }
 
-  if (with_image)
+  if (with_image) {
     AddImage(button);
+  }
 
   window->AddChildView(button);
   window->Layout();
@@ -595,10 +599,11 @@ class TestMenuButtonCustomPopupDelegate : public CefMenuButtonDelegate,
   }
 
   void OnWindowDestroyed(CefRefPtr<CefWindow> window) override {
-    if (can_activate_)
+    if (can_activate_) {
       EXPECT_TRUE(got_focus_);
-    else
+    } else {
       EXPECT_FALSE(got_focus_);
+    }
 
     // Complete the test by closing the parent window.
     parent_window_->Close();
diff --git a/tests/ceftests/views/panel_unittest.cc b/tests/ceftests/views/panel_unittest.cc
index 5cd1954cf..370635e8e 100644
--- a/tests/ceftests/views/panel_unittest.cc
+++ b/tests/ceftests/views/panel_unittest.cc
@@ -37,10 +37,11 @@ void CreatePanel(CefRefPtr<CefPanelDelegate> delegate) {
   EXPECT_STREQ("Panel", panel->GetTypeString().ToString().c_str());
   EXPECT_TRUE(panel->IsValid());
   EXPECT_FALSE(panel->IsAttached());
-  if (delegate)
+  if (delegate) {
     EXPECT_EQ(delegate.get(), panel->GetDelegate().get());
-  else
+  } else {
     EXPECT_FALSE(panel->GetDelegate().get());
+  }
   EXPECT_EQ(0, panel->GetID());
   EXPECT_FALSE(panel->GetParentView().get());
   EXPECT_EQ(CefRect(0, 0, 0, 0), panel->GetBounds());
@@ -292,10 +293,11 @@ void ChildRemove(CefRefPtr<ParentPanelDelegate> parent_delegate,
   EXPECT_TRUE(child_delegate->IsReset());
 
   // Remove the child view.
-  if (remove_all)
+  if (remove_all) {
     parent_panel->RemoveAllChildViews();
-  else
+  } else {
     parent_panel->RemoveChildView(child_panel);
+  }
 
   // Verify final callback state.
   ChildVerifyFinalCallbackState(parent_delegate, parent_panel, child_delegate,
@@ -850,10 +852,11 @@ void FillLayoutSizeHierarchyWithDelegate(bool size_from_parent) {
   EXPECT_EQ(CefRect(0, 0, 0, 0), panel_child->GetBounds());
 
   // With delegates the size can come from either the parent or child.
-  if (size_from_parent)
+  if (size_from_parent) {
     delegate_parent->preferred_size_ = expected_size;
-  else
+  } else {
     delegate_child->preferred_size_ = expected_size;
+  }
 
   // FillLayout is the default Layout. Both panels should end up with the same
   // size.
@@ -944,8 +947,9 @@ void BoxLayoutSizeHierarchy(bool with_delegate,
                             int child1_flex = 0,
                             int child2_flex = 0) {
   CefRefPtr<SizingPanelDelegate> delegate_parent;
-  if (with_delegate)
+  if (with_delegate) {
     delegate_parent = new SizingPanelDelegate();
+  }
   CefRefPtr<CefPanel> panel_parent = CefPanel::CreatePanel(delegate_parent);
 
   CefRefPtr<SizingPanelDelegate> delegate_child1, delegate_child2;
@@ -963,10 +967,11 @@ void BoxLayoutSizeHierarchy(bool with_delegate,
 
   // Give the parent a size.
   CefSize initial_parent_size(kBLParentSize, kBLParentSize);
-  if (with_delegate)
+  if (with_delegate) {
     delegate_parent->preferred_size_ = initial_parent_size;
-  else
+  } else {
     panel_parent->SetSize(initial_parent_size);
+  }
 
   // Give the children a size smaller than the parent.
   CefSize initial_child_size(kBLChildSize, kBLChildSize);
@@ -987,10 +992,12 @@ void BoxLayoutSizeHierarchy(bool with_delegate,
   if (child1_flex > 0 || child2_flex > 0) {
     // Flex will apply relative stretch in the main axis direction.
     CefRefPtr<CefBoxLayout> layout = panel_parent->GetLayout()->AsBoxLayout();
-    if (child1_flex > 0)
+    if (child1_flex > 0) {
       layout->SetFlexForView(panel_child1, child1_flex);
-    if (child2_flex > 0)
+    }
+    if (child2_flex > 0) {
       layout->SetFlexForView(panel_child2, child2_flex);
+    }
   }
 
   if (with_delegate) {
diff --git a/tests/ceftests/views/test_window_delegate.cc b/tests/ceftests/views/test_window_delegate.cc
index c0ea3c0d5..94d19ec93 100644
--- a/tests/ceftests/views/test_window_delegate.cc
+++ b/tests/ceftests/views/test_window_delegate.cc
@@ -88,10 +88,11 @@ void TestWindowDelegate::OnWindowCreated(CefRefPtr<CefWindow> window) {
   // Size will come from GetGetInitialBounds() or GetPreferredSize() on
   // initial Window creation.
   EXPECT_TRUE(got_get_initial_bounds_);
-  if (config_->window_origin.IsEmpty())
+  if (config_->window_origin.IsEmpty()) {
     EXPECT_TRUE(got_get_preferred_size_);
-  else
+  } else {
     EXPECT_FALSE(got_get_preferred_size_);
+  }
 
   CefRect client_bounds = window->GetBounds();
   if (!config_->window_origin.IsEmpty()) {
@@ -116,8 +117,9 @@ void TestWindowDelegate::OnWindowCreated(CefRefPtr<CefWindow> window) {
   }
 
   // Run the callback.
-  if (!config_->on_window_created.is_null())
+  if (!config_->on_window_created.is_null()) {
     std::move(config_->on_window_created).Run(window);
+  }
 
   if (config_->close_window) {
     // Close the window asynchronously.
@@ -143,8 +145,9 @@ void TestWindowDelegate::OnWindowDestroyed(CefRefPtr<CefWindow> window) {
   EXPECT_FALSE(window->IsDrawn());
 
   // Run the callback.
-  if (!config_->on_window_destroyed.is_null())
+  if (!config_->on_window_destroyed.is_null()) {
     std::move(config_->on_window_destroyed).Run(window);
+  }
 
   window_ = nullptr;
 
@@ -174,15 +177,17 @@ CefSize TestWindowDelegate::GetPreferredSize(CefRefPtr<CefView> view) {
 
 bool TestWindowDelegate::OnAccelerator(CefRefPtr<CefWindow> window,
                                        int command_id) {
-  if (!config_->on_accelerator.is_null())
+  if (!config_->on_accelerator.is_null()) {
     return config_->on_accelerator.Run(window_, command_id);
+  }
   return false;
 }
 
 bool TestWindowDelegate::OnKeyEvent(CefRefPtr<CefWindow> window,
                                     const CefKeyEvent& event) {
-  if (!config_->on_key_event.is_null())
+  if (!config_->on_key_event.is_null()) {
     return config_->on_key_event.Run(window_, event);
+  }
   return false;
 }
 
@@ -201,8 +206,9 @@ TestWindowDelegate::~TestWindowDelegate() {
 }
 
 void TestWindowDelegate::OnCloseWindow() {
-  if (!window_)
+  if (!window_) {
     return;
+  }
 
   EXPECT_TRUE(window_->IsValid());
   EXPECT_FALSE(window_->IsClosed());
diff --git a/tests/ceftests/views/window_unittest.cc b/tests/ceftests/views/window_unittest.cc
index 3e85dcb66..0c8d6b824 100644
--- a/tests/ceftests/views/window_unittest.cc
+++ b/tests/ceftests/views/window_unittest.cc
@@ -409,16 +409,18 @@ void TriggerAccelerator(CefRefPtr<CefWindow> window) {
 }
 
 bool OnKeyEvent(CefRefPtr<CefWindow> window, const CefKeyEvent& event) {
-  if (event.type != KEYEVENT_RAWKEYDOWN)
+  if (event.type != KEYEVENT_RAWKEYDOWN) {
     return false;
+  }
 
   if (event.windows_key_code == VK_MENU) {
     // First we get the ALT key press in all cases.
     EXPECT_FALSE(got_key_event_char);
-    if (got_key_event_alt_count == 0)
+    if (got_key_event_alt_count == 0) {
       EXPECT_FALSE(got_accelerator);
-    else
+    } else {
       EXPECT_TRUE(got_accelerator);
+    }
 
     EXPECT_EQ(EVENTFLAG_ALT_DOWN, static_cast<int>(event.modifiers));
     got_key_event_alt_count++;
diff --git a/tests/ceftests/webui_unittest.cc b/tests/ceftests/webui_unittest.cc
index 2ce99bb59..c02acf911 100644
--- a/tests/ceftests/webui_unittest.cc
+++ b/tests/ceftests/webui_unittest.cc
@@ -81,10 +81,11 @@ class WebUITestHandler : public TestHandler {
 
   void DestroyTest() override {
     EXPECT_TRUE(got_loading_state_done_);
-    if (expected_error_code_ == ERR_NONE)
+    if (expected_error_code_ == ERR_NONE) {
       EXPECT_FALSE(got_load_error_);
-    else
+    } else {
       EXPECT_TRUE(got_load_error_);
+    }
 
     TestHandler::DestroyTest();
   }
@@ -93,8 +94,9 @@ class WebUITestHandler : public TestHandler {
   void NextNavIfDone(const std::string& url) {
     bool done = false;
     if (expected_error_code_ == ERR_NONE) {
-      if (got_loading_state_done_)
+      if (got_loading_state_done_) {
         done = true;
+      }
     } else if (got_load_error_ && got_loading_state_done_) {
       done = true;
     }
@@ -102,8 +104,9 @@ class WebUITestHandler : public TestHandler {
     if (done) {
       // Verify that we navigated to the expected URL.
       std::string expected_url = expected_url_;
-      if (expected_url.empty() && url_index_ < url_list_.size())
+      if (expected_url.empty() && url_index_ < url_list_.size()) {
         expected_url = url_list_[url_index_];
+      }
       EXPECT_STREQ(expected_url.c_str(), url.c_str());
 
       NextNav();
diff --git a/tests/gtest/teamcity/include/teamcity_gtest.h b/tests/gtest/teamcity/include/teamcity_gtest.h
index acb1cd259..236f6f98c 100644
--- a/tests/gtest/teamcity/include/teamcity_gtest.h
+++ b/tests/gtest/teamcity/include/teamcity_gtest.h
@@ -25,30 +25,31 @@
 namespace jetbrains {
 namespace teamcity {
 
-class TeamcityGoogleTestEventListener: public ::testing::EmptyTestEventListener {
-public:
-    TeamcityGoogleTestEventListener(const std::string& flowid);
-    TeamcityGoogleTestEventListener();
+class TeamcityGoogleTestEventListener
+    : public ::testing::EmptyTestEventListener {
+ public:
+  TeamcityGoogleTestEventListener(const std::string& flowid);
+  TeamcityGoogleTestEventListener();
 
-    // Fired before the test case starts.
-    virtual void OnTestCaseStart(const ::testing::TestCase& test_case);
-    // Fired before the test starts.
-    virtual void OnTestStart(const ::testing::TestInfo& test_info);
-    // Fired after the test ends.
-    virtual void OnTestEnd(const ::testing::TestInfo& test_info);
-    // Fired after the test case ends.
-    virtual void OnTestCaseEnd(const ::testing::TestCase& test_case);
+  // Fired before the test case starts.
+  virtual void OnTestCaseStart(const ::testing::TestCase& test_case);
+  // Fired before the test starts.
+  virtual void OnTestStart(const ::testing::TestInfo& test_info);
+  // Fired after the test ends.
+  virtual void OnTestEnd(const ::testing::TestInfo& test_info);
+  // Fired after the test case ends.
+  virtual void OnTestCaseEnd(const ::testing::TestCase& test_case);
 
-private:
-    TeamcityMessages messages;
-    std::string flowid;
+ private:
+  TeamcityMessages messages;
+  std::string flowid;
 
-    // Prevent copying.
-    TeamcityGoogleTestEventListener(const TeamcityGoogleTestEventListener&);
-    void operator =(const TeamcityGoogleTestEventListener&);
+  // Prevent copying.
+  TeamcityGoogleTestEventListener(const TeamcityGoogleTestEventListener&);
+  void operator=(const TeamcityGoogleTestEventListener&);
 };
 
-}
-}
+}  // namespace teamcity
+}  // namespace jetbrains
 
 #endif /* H_TEAMCITY_GTEST */
diff --git a/tests/gtest/teamcity/src/teamcity_gtest.cpp b/tests/gtest/teamcity/src/teamcity_gtest.cpp
index 8600c2c12..fb4dc6761 100644
--- a/tests/gtest/teamcity/src/teamcity_gtest.cpp
+++ b/tests/gtest/teamcity/src/teamcity_gtest.cpp
@@ -22,65 +22,64 @@ namespace teamcity {
 using namespace testing;
 
 TeamcityGoogleTestEventListener::TeamcityGoogleTestEventListener() {
-    flowid = getFlowIdFromEnvironment();
+  flowid = getFlowIdFromEnvironment();
 }
 
-TeamcityGoogleTestEventListener::TeamcityGoogleTestEventListener(const std::string& flowid_)
-    : flowid(flowid_) {
-}
+TeamcityGoogleTestEventListener::TeamcityGoogleTestEventListener(
+    const std::string& flowid_)
+    : flowid(flowid_) {}
 
 // Fired before the test case starts.
-void TeamcityGoogleTestEventListener::OnTestCaseStart(const TestCase& test_case) {
-    messages.suiteStarted(test_case.name(), flowid);
+void TeamcityGoogleTestEventListener::OnTestCaseStart(
+    const TestCase& test_case) {
+  messages.suiteStarted(test_case.name(), flowid);
 }
 
 // Fired before the test starts.
 void TeamcityGoogleTestEventListener::OnTestStart(const TestInfo& test_info) {
-    messages.testStarted(test_info.name(), flowid);
+  messages.testStarted(test_info.name(), flowid);
 }
 
 // Fired after the test ends.
 void TeamcityGoogleTestEventListener::OnTestEnd(const TestInfo& test_info) {
-    const TestResult* result = test_info.result();
-    if (result->Failed()) {
-        std::string message;
-        std::string details;
-        for (int i = 0; i < result->total_part_count(); ++i) {
-            const TestPartResult& partResult = result->GetTestPartResult(i);
-            if (partResult.passed()) {
-                continue;
-            }
+  const TestResult* result = test_info.result();
+  if (result->Failed()) {
+    std::string message;
+    std::string details;
+    for (int i = 0; i < result->total_part_count(); ++i) {
+      const TestPartResult& partResult = result->GetTestPartResult(i);
+      if (partResult.passed()) {
+        continue;
+      }
 
-            if (message.empty()) {
-                message = partResult.summary();
-            }
+      if (message.empty()) {
+        message = partResult.summary();
+      }
 
-            if (!details.empty()) {
-                details.append("\n");
-            }
-            details.append(partResult.message());
+      if (!details.empty()) {
+        details.append("\n");
+      }
+      details.append(partResult.message());
 
-            if (partResult.file_name() && partResult.line_number() >= 0) {
-                std::stringstream ss;
-                ss << "\n at " << partResult.file_name() << ":" << partResult.line_number();
-                details.append(ss.str());
-            }
-        }
-
-        messages.testFailed(
-            test_info.name(),
-            !message.empty() ? message : "failed",
-            details,
-            flowid
-        );
+      if (partResult.file_name() && partResult.line_number() >= 0) {
+        std::stringstream ss;
+        ss << "\n at " << partResult.file_name() << ":"
+           << partResult.line_number();
+        details.append(ss.str());
+      }
     }
-    messages.testFinished(test_info.name(), static_cast<int>(result->elapsed_time()), flowid);
+
+    messages.testFailed(test_info.name(), !message.empty() ? message : "failed",
+                        details, flowid);
+  }
+  messages.testFinished(test_info.name(),
+                        static_cast<int>(result->elapsed_time()), flowid);
 }
 
 // Fired after the test case ends.
 void TeamcityGoogleTestEventListener::OnTestCaseEnd(const TestCase& test_case) {
-    messages.suiteFinished(test_case.name(), flowid);
+  messages.suiteFinished(test_case.name(), flowid);
 }
 
-}
-}
+}  // namespace teamcity
+}  // namespace jetbrains
diff --git a/tests/gtest/teamcity/src/teamcity_messages.cpp b/tests/gtest/teamcity/src/teamcity_messages.cpp
index 39f868a02..284f8b4c4 100644
--- a/tests/gtest/teamcity/src/teamcity_messages.cpp
+++ b/tests/gtest/teamcity/src/teamcity_messages.cpp
@@ -1,11 +1,11 @@
 /* Copyright 2011 JetBrains s.r.o.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *     http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -13,7 +13,7 @@
  * limitations under the License.
  *
  * $Revision: 88625 $
-*/
+ */
 
 #include "tests/gtest/teamcity/src/teamcity_messages.h"
 
@@ -24,166 +24,192 @@ namespace jetbrains {
 namespace teamcity {
 
 std::string getFlowIdFromEnvironment() {
-#if (defined(WIN32) || defined(_WIN32) || defined(__WIN32)) && !defined(__CYGWIN__) && !defined(__MINGW32__)
-    char *flowId = NULL;
-    size_t sz = 0;
-    std::string result;
-    if(!_dupenv_s(&flowId, &sz,"TEAMCITY_PROCESS_FLOW_ID")) {
-        result = flowId != NULL ? flowId : "";
-        free(flowId);
-    }
+#if (defined(WIN32) || defined(_WIN32) || defined(__WIN32)) && \
+    !defined(__CYGWIN__) && !defined(__MINGW32__)
+  char* flowId = NULL;
+  size_t sz = 0;
+  std::string result;
+  if (!_dupenv_s(&flowId, &sz, "TEAMCITY_PROCESS_FLOW_ID")) {
+    result = flowId != NULL ? flowId : "";
+    free(flowId);
+  }
 
-    return result;
+  return result;
 #else
-    const char *flowId = getenv("TEAMCITY_PROCESS_FLOW_ID");
-    return flowId == NULL ? "" : flowId;
+  const char* flowId = getenv("TEAMCITY_PROCESS_FLOW_ID");
+  return flowId == NULL ? "" : flowId;
 #endif
 }
 
 bool underTeamcity() {
-#if (defined(WIN32) || defined(_WIN32) || defined(__WIN32)) && !defined(__CYGWIN__) && !defined(__MINGW32__)
-    char *teamCityProjectName = 0;
-    size_t sz = 0;
-    bool result = false;
-    if(!_dupenv_s(&teamCityProjectName, &sz, "TEAMCITY_PROJECT_NAME")) {
-        result = teamCityProjectName != NULL;
-        free(teamCityProjectName);
-    }
+#if (defined(WIN32) || defined(_WIN32) || defined(__WIN32)) && \
+    !defined(__CYGWIN__) && !defined(__MINGW32__)
+  char* teamCityProjectName = 0;
+  size_t sz = 0;
+  bool result = false;
+  if (!_dupenv_s(&teamCityProjectName, &sz, "TEAMCITY_PROJECT_NAME")) {
+    result = teamCityProjectName != NULL;
+    free(teamCityProjectName);
+  }
 
-    return result;
+  return result;
 #else
-    return getenv("TEAMCITY_PROJECT_NAME") != NULL;
+  return getenv("TEAMCITY_PROJECT_NAME") != NULL;
 #endif
 }
 
-TeamcityMessages::TeamcityMessages()
-: m_out(&std::cout)
-{}
+TeamcityMessages::TeamcityMessages() : m_out(&std::cout) {}
 
-void TeamcityMessages::setOutput(std::ostream &out) {
-    m_out = &out;
+void TeamcityMessages::setOutput(std::ostream& out) {
+  m_out = &out;
 }
 
-std::string TeamcityMessages::escape(const std::string &s) {
-    std::string result;
-    result.reserve(s.length());
+std::string TeamcityMessages::escape(const std::string& s) {
+  std::string result;
+  result.reserve(s.length());
 
-    for (size_t i = 0; i < s.length(); i++) {
-        char c = s[i];
+  for (size_t i = 0; i < s.length(); i++) {
+    char c = s[i];
 
-        switch (c) {
-        case '\n': result.append("|n"); break;
-        case '\r': result.append("|r"); break;
-        case '\'': result.append("|'"); break;
-        case '|':  result.append("||"); break;
-        case ']':  result.append("|]"); break;
-        default:   result.append(&c, 1);
-        }
+    switch (c) {
+      case '\n':
+        result.append("|n");
+        break;
+      case '\r':
+        result.append("|r");
+        break;
+      case '\'':
+        result.append("|'");
+        break;
+      case '|':
+        result.append("||");
+        break;
+      case ']':
+        result.append("|]");
+        break;
+      default:
+        result.append(&c, 1);
     }
+  }
 
-    return result;
+  return result;
 }
 
-void TeamcityMessages::openMsg(const std::string &name) {
-    // endl for http://jetbrains.net/tracker/issue/TW-4412
-    *m_out << std::endl << "##teamcity[" << name;
+void TeamcityMessages::openMsg(const std::string& name) {
+  // endl for http://jetbrains.net/tracker/issue/TW-4412
+  *m_out << std::endl << "##teamcity[" << name;
 }
 
 void TeamcityMessages::closeMsg() {
-    *m_out << "]";
-    // endl for http://jetbrains.net/tracker/issue/TW-4412
-    *m_out << std::endl;
+  *m_out << "]";
+  // endl for http://jetbrains.net/tracker/issue/TW-4412
+  *m_out << std::endl;
 }
 
-void TeamcityMessages::writeProperty(const std::string &name, const std::string &value) {
-    *m_out << " " << name << "='" << escape(value) << "'";
+void TeamcityMessages::writeProperty(const std::string& name,
+                                     const std::string& value) {
+  *m_out << " " << name << "='" << escape(value) << "'";
 }
 
-void TeamcityMessages::suiteStarted(const std::string &name, const std::string &flowid) {
-    openMsg("testSuiteStarted");
-    writeProperty("name", name);
-    if(flowid.length() > 0) {
-        writeProperty("flowId", flowid);
-    }
+void TeamcityMessages::suiteStarted(const std::string& name,
+                                    const std::string& flowid) {
+  openMsg("testSuiteStarted");
+  writeProperty("name", name);
+  if (flowid.length() > 0) {
+    writeProperty("flowId", flowid);
+  }
 
-    closeMsg();
+  closeMsg();
 }
 
-void TeamcityMessages::suiteFinished(const std::string &name, const std::string &flowid) {
-    openMsg("testSuiteFinished");
-    writeProperty("name", name);
-    if(flowid.length() > 0) {
-        writeProperty("flowId", flowid);
-    }
+void TeamcityMessages::suiteFinished(const std::string& name,
+                                     const std::string& flowid) {
+  openMsg("testSuiteFinished");
+  writeProperty("name", name);
+  if (flowid.length() > 0) {
+    writeProperty("flowId", flowid);
+  }
 
-    closeMsg();
+  closeMsg();
 }
 
-void TeamcityMessages::testStarted(const std::string &name, const std::string &flowid, bool captureStandardOutput) {
-    openMsg("testStarted");
-    writeProperty("name", name);
-    if(flowid.length() > 0) {
-        writeProperty("flowId", flowid);
-    }
+void TeamcityMessages::testStarted(const std::string& name,
+                                   const std::string& flowid,
+                                   bool captureStandardOutput) {
+  openMsg("testStarted");
+  writeProperty("name", name);
+  if (flowid.length() > 0) {
+    writeProperty("flowId", flowid);
+  }
 
-    if(captureStandardOutput) {
-        writeProperty("captureStandardOutput", "true"); // false by default
-    }
+  if (captureStandardOutput) {
+    writeProperty("captureStandardOutput", "true");  // false by default
+  }
 
-    closeMsg();
+  closeMsg();
 }
 
-void TeamcityMessages::testFinished(const std::string &name, int durationMs, const std::string &flowid) {
-    openMsg("testFinished");
+void TeamcityMessages::testFinished(const std::string& name,
+                                    int durationMs,
+                                    const std::string& flowid) {
+  openMsg("testFinished");
 
-    writeProperty("name", name);
+  writeProperty("name", name);
 
-    if(flowid.length() > 0) {
-        writeProperty("flowId", flowid);
-    }
+  if (flowid.length() > 0) {
+    writeProperty("flowId", flowid);
+  }
 
-    if(durationMs >= 0) {
-        std::stringstream out(std::ios_base::out);
-        out << durationMs;
-        writeProperty("duration", out.str());
-    }
+  if (durationMs >= 0) {
+    std::stringstream out(std::ios_base::out);
+    out << durationMs;
+    writeProperty("duration", out.str());
+  }
 
-    closeMsg();
+  closeMsg();
 }
 
-void TeamcityMessages::testFailed(const std::string &name, const std::string &message, const std::string &details, const std::string &flowid) {
-    openMsg("testFailed");
-    writeProperty("name", name);
-    writeProperty("message", message);
-    writeProperty("details", details);
-    if(flowid.length() > 0) {
-        writeProperty("flowId", flowid);
-    }
+void TeamcityMessages::testFailed(const std::string& name,
+                                  const std::string& message,
+                                  const std::string& details,
+                                  const std::string& flowid) {
+  openMsg("testFailed");
+  writeProperty("name", name);
+  writeProperty("message", message);
+  writeProperty("details", details);
+  if (flowid.length() > 0) {
+    writeProperty("flowId", flowid);
+  }
 
-    closeMsg();
+  closeMsg();
 }
 
-void TeamcityMessages::testIgnored(const std::string &name, const std::string &message, const std::string &flowid) {
-    openMsg("testIgnored");
-    writeProperty("name", name);
-    writeProperty("message", message);
-    if(flowid.length() > 0) {
-        writeProperty("flowId", flowid);
-    }
+void TeamcityMessages::testIgnored(const std::string& name,
+                                   const std::string& message,
+                                   const std::string& flowid) {
+  openMsg("testIgnored");
+  writeProperty("name", name);
+  writeProperty("message", message);
+  if (flowid.length() > 0) {
+    writeProperty("flowId", flowid);
+  }
 
-    closeMsg();
+  closeMsg();
 }
 
-void TeamcityMessages::testOutput(const std::string &name, const std::string &output, const std::string &flowid, bool isStdError) {
-    openMsg(isStdError ? "testStdErr" : "testStdOut");
-    writeProperty("name", name);
-    writeProperty("out", output);
-    if(flowid.length() > 0) {
-        writeProperty("flowId", flowid);
-    }
+void TeamcityMessages::testOutput(const std::string& name,
+                                  const std::string& output,
+                                  const std::string& flowid,
+                                  bool isStdError) {
+  openMsg(isStdError ? "testStdErr" : "testStdOut");
+  writeProperty("name", name);
+  writeProperty("out", output);
+  if (flowid.length() > 0) {
+    writeProperty("flowId", flowid);
+  }
 
-    closeMsg();
+  closeMsg();
 }
 
-}
-}
+}  // namespace teamcity
+}  // namespace jetbrains
diff --git a/tests/gtest/teamcity/src/teamcity_messages.h b/tests/gtest/teamcity/src/teamcity_messages.h
index 8f64565dd..409cb83cb 100644
--- a/tests/gtest/teamcity/src/teamcity_messages.h
+++ b/tests/gtest/teamcity/src/teamcity_messages.h
@@ -1,11 +1,11 @@
 /* Copyright 2011 JetBrains s.r.o.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *     http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -13,7 +13,7 @@
  * limitations under the License.
  *
  * $Revision: 88625 $
-*/
+ */
 
 #ifndef H_TEAMCITY_MESSAGES
 #define H_TEAMCITY_MESSAGES
@@ -28,34 +28,48 @@ std::string getFlowIdFromEnvironment();
 bool underTeamcity();
 
 class TeamcityMessages {
-    std::ostream *m_out;
+  std::ostream* m_out;
 
-protected:
-    std::string escape(const std::string &s);
+ protected:
+  std::string escape(const std::string& s);
 
-    void openMsg(const std::string &name);
-    void writeProperty(const std::string &name, const std::string &value);
-    void closeMsg();
+  void openMsg(const std::string& name);
+  void writeProperty(const std::string& name, const std::string& value);
+  void closeMsg();
 
-public:
-    static const bool StdErr = true;
-    static const bool StdOut = false;
+ public:
+  static const bool StdErr = true;
+  static const bool StdOut = false;
 
-    TeamcityMessages();
+  TeamcityMessages();
 
-    void setOutput(std::ostream &);
+  void setOutput(std::ostream&);
 
-    void suiteStarted(const std::string &name, const std::string &flowid =  std::string());
-    void suiteFinished(const std::string &name, const std::string &flowid =  std::string());
+  void suiteStarted(const std::string& name,
+                    const std::string& flowid = std::string());
+  void suiteFinished(const std::string& name,
+                     const std::string& flowid = std::string());
 
-    void testStarted(const std::string &name, const std::string &flowid =  std::string(), bool captureStandardOutput = false);
-    void testFailed(const std::string &name, const std::string &message, const std::string &details, const std::string &flowid =  std::string());
-    void testIgnored(const std::string &name, const std::string &message, const std::string &flowid =  std::string());
-    void testOutput(const std::string &name, const std::string &output, const std::string &flowid, bool isStdErr = StdOut);
-    void testFinished(const std::string &name, int durationMs = -1, const std::string &flowid = std::string());
+  void testStarted(const std::string& name,
+                   const std::string& flowid = std::string(),
+                   bool captureStandardOutput = false);
+  void testFailed(const std::string& name,
+                  const std::string& message,
+                  const std::string& details,
+                  const std::string& flowid = std::string());
+  void testIgnored(const std::string& name,
+                   const std::string& message,
+                   const std::string& flowid = std::string());
+  void testOutput(const std::string& name,
+                  const std::string& output,
+                  const std::string& flowid,
+                  bool isStdErr = StdOut);
+  void testFinished(const std::string& name,
+                    int durationMs = -1,
+                    const std::string& flowid = std::string());
 };
 
-}
-}
+}  // namespace teamcity
+}  // namespace jetbrains
 
 #endif /* H_TEAMCITY_MESSAGES */
diff --git a/tests/shared/browser/client_app_browser.cc b/tests/shared/browser/client_app_browser.cc
index ef2c990f2..3c6fa19df 100644
--- a/tests/shared/browser/client_app_browser.cc
+++ b/tests/shared/browser/client_app_browser.cc
@@ -33,8 +33,9 @@ void ClientAppBrowser::PopulateSettings(CefRefPtr<CefCommandLine> command_line,
   if (!cookieable_schemes.empty()) {
     std::string list_str;
     for (const auto& scheme : cookieable_schemes) {
-      if (!list_str.empty())
+      if (!list_str.empty()) {
         list_str += ",";
+      }
       list_str += scheme;
     }
     CefString(&settings.cookieable_schemes_list) = list_str;
@@ -82,8 +83,9 @@ void ClientAppBrowser::OnBeforeCommandLineProcessing(
 #endif
 
     DelegateSet::iterator it = delegates_.begin();
-    for (; it != delegates_.end(); ++it)
+    for (; it != delegates_.end(); ++it) {
       (*it)->OnBeforeCommandLineProcessing(this, command_line);
+    }
   }
 }
 
@@ -91,29 +93,33 @@ void ClientAppBrowser::OnRegisterCustomPreferences(
     cef_preferences_type_t type,
     CefRawPtr<CefPreferenceRegistrar> registrar) {
   DelegateSet::iterator it = delegates_.begin();
-  for (; it != delegates_.end(); ++it)
+  for (; it != delegates_.end(); ++it) {
     (*it)->OnRegisterCustomPreferences(this, type, registrar);
+  }
 }
 
 void ClientAppBrowser::OnContextInitialized() {
   DelegateSet::iterator it = delegates_.begin();
-  for (; it != delegates_.end(); ++it)
+  for (; it != delegates_.end(); ++it) {
     (*it)->OnContextInitialized(this);
+  }
 }
 
 void ClientAppBrowser::OnBeforeChildProcessLaunch(
     CefRefPtr<CefCommandLine> command_line) {
   DelegateSet::iterator it = delegates_.begin();
-  for (; it != delegates_.end(); ++it)
+  for (; it != delegates_.end(); ++it) {
     (*it)->OnBeforeChildProcessLaunch(this, command_line);
+  }
 }
 
 void ClientAppBrowser::OnScheduleMessagePumpWork(int64 delay) {
   // Only used when `--external-message-pump` is passed via the command-line.
   MainMessageLoopExternalPump* message_pump =
       MainMessageLoopExternalPump::Get();
-  if (message_pump)
+  if (message_pump) {
     message_pump->OnScheduleMessagePumpWork(delay);
+  }
 }
 
 }  // namespace client
diff --git a/tests/shared/browser/extension_util.cc b/tests/shared/browser/extension_util.cc
index 18bf23d0d..088316e4e 100644
--- a/tests/shared/browser/extension_util.cc
+++ b/tests/shared/browser/extension_util.cc
@@ -94,8 +94,9 @@ void GetInternalManifest(const std::string& extension_path,
   CefRefPtr<CefValue> value =
       CefParseJSONAndReturnError(manifest_contents, JSON_PARSER_RFC, error_msg);
   if (!value || value->GetType() != VTYPE_DICTIONARY) {
-    if (error_msg.empty())
+    if (error_msg.empty()) {
       error_msg = "Incorrectly formatted dictionary contents.";
+    }
     LOG(ERROR) << "Failed to parse manifest from " << manifest_path << "; "
                << error_msg.ToString();
     RunManifestCallback(std::move(callback), nullptr);
@@ -143,10 +144,12 @@ std::string GetInternalExtensionResourcePath(
 std::string GetExtensionResourcePath(const std::string& extension_path,
                                      bool* internal) {
   const bool is_internal = IsInternalExtension(extension_path);
-  if (internal)
+  if (internal) {
     *internal = is_internal;
-  if (is_internal)
+  }
+  if (is_internal) {
     return GetInternalExtensionResourcePath(extension_path);
+  }
   return extension_path;
 }
 
@@ -227,8 +230,9 @@ std::string GetExtensionURL(CefRefPtr<CefExtension> extension) {
   if (browser_action) {
     const std::string& default_popup =
         browser_action->GetString("default_popup");
-    if (!default_popup.empty())
+    if (!default_popup.empty()) {
       return GetExtensionOrigin(extension->GetIdentifier()) + default_popup;
+    }
   }
 
   return std::string();
diff --git a/tests/shared/browser/file_util.cc b/tests/shared/browser/file_util.cc
index 5c3da37d1..d1ccaac6e 100644
--- a/tests/shared/browser/file_util.cc
+++ b/tests/shared/browser/file_util.cc
@@ -35,14 +35,17 @@ const char kPathSep = '/';
 bool ReadFileToString(const std::string& path,
                       std::string* contents,
                       size_t max_size) {
-  if (!AllowFileIO())
+  if (!AllowFileIO()) {
     return false;
+  }
 
-  if (contents)
+  if (contents) {
     contents->clear();
+  }
   FILE* file = fopen(path.c_str(), "rb");
-  if (!file)
+  if (!file) {
     return false;
+  }
 
   const size_t kBufferSize = 1 << 16;
   std::unique_ptr<char[]> buf(new char[kBufferSize]);
@@ -53,8 +56,9 @@ bool ReadFileToString(const std::string& path,
   // Many files supplied in |path| have incorrect size (proc files etc).
   // Hence, the file is read sequentially as opposed to a one-shot read.
   while ((len = fread(buf.get(), 1, kBufferSize, file)) > 0) {
-    if (contents)
+    if (contents) {
       contents->append(buf.get(), std::min(len, max_size - size));
+    }
 
     if ((max_size - size) < len) {
       read_status = false;
@@ -70,19 +74,22 @@ bool ReadFileToString(const std::string& path,
 }
 
 int WriteFile(const std::string& path, const char* data, int size) {
-  if (!AllowFileIO())
+  if (!AllowFileIO()) {
     return -1;
+  }
 
   FILE* file = fopen(path.c_str(), "wb");
-  if (!file)
+  if (!file) {
     return -1;
+  }
 
   int written = 0;
 
   do {
     size_t write = fwrite(data + written, 1, size - written, file);
-    if (write == 0)
+    if (write == 0) {
       break;
+    }
     written += static_cast<int>(write);
   } while (written < size);
 
@@ -92,27 +99,33 @@ int WriteFile(const std::string& path, const char* data, int size) {
 }
 
 std::string JoinPath(const std::string& path1, const std::string& path2) {
-  if (path1.empty() && path2.empty())
+  if (path1.empty() && path2.empty()) {
     return std::string();
-  if (path1.empty())
+  }
+  if (path1.empty()) {
     return path2;
-  if (path2.empty())
+  }
+  if (path2.empty()) {
     return path1;
+  }
 
   std::string result = path1;
-  if (result[result.size() - 1] != kPathSep)
+  if (result[result.size() - 1] != kPathSep) {
     result += kPathSep;
-  if (path2[0] == kPathSep)
+  }
+  if (path2[0] == kPathSep) {
     result += path2.substr(1);
-  else
+  } else {
     result += path2;
+  }
   return result;
 }
 
 std::string GetFileExtension(const std::string& path) {
   size_t sep = path.find_last_of(".");
-  if (sep != std::string::npos)
+  if (sep != std::string::npos) {
     return path.substr(sep + 1);
+  }
   return std::string();
 }
 
diff --git a/tests/shared/browser/main_message_loop_external_pump.cc b/tests/shared/browser/main_message_loop_external_pump.cc
index b589f6671..6579e87bd 100644
--- a/tests/shared/browser/main_message_loop_external_pump.cc
+++ b/tests/shared/browser/main_message_loop_external_pump.cc
@@ -56,8 +56,9 @@ void MainMessageLoopExternalPump::OnScheduleWork(int64 delay_ms) {
     DoWork();
   } else {
     // Never wait longer than the maximum allowed time.
-    if (delay_ms > kMaxTimerDelay)
+    if (delay_ms > kMaxTimerDelay) {
       delay_ms = kMaxTimerDelay;
+    }
 
     // Results in call to OnTimerTimeout() after the specified delay.
     SetTimer(delay_ms);
diff --git a/tests/shared/browser/main_message_loop_external_pump_linux.cc b/tests/shared/browser/main_message_loop_external_pump_linux.cc
index 4e8ba0d86..5f94afc3a 100644
--- a/tests/shared/browser/main_message_loop_external_pump_linux.cc
+++ b/tests/shared/browser/main_message_loop_external_pump_linux.cc
@@ -109,8 +109,9 @@ class MainMessageLoopExternalPumpLinux : public MainMessageLoopExternalPump {
 // Return a timeout suitable for the glib loop, -1 to block forever,
 // 0 to return right away, or a timeout in milliseconds from now.
 int GetTimeIntervalMilliseconds(const CefTime& from) {
-  if (from.GetDoubleT() == 0.0)
+  if (from.GetDoubleT() == 0.0) {
     return -1;
+  }
 
   CefTime now;
   now.Now();
@@ -206,8 +207,9 @@ int MainMessageLoopExternalPumpLinux::Run() {
     bool block = !more_work_is_plausible;
 
     more_work_is_plausible = g_main_context_iteration(context_, block);
-    if (should_quit_)
+    if (should_quit_) {
       break;
+    }
   }
 
   // We need to run the message pump until it is idle. However we don't have
@@ -254,10 +256,12 @@ bool MainMessageLoopExternalPumpLinux::HandleCheck() {
     if (num_bytes < sizeof(int64)) {
       NOTREACHED() << "Error reading from the wakeup pipe.";
     }
-    if (num_bytes == sizeof(int64))
+    if (num_bytes == sizeof(int64)) {
       OnScheduleWork(delay_ms[0]);
-    if (num_bytes == sizeof(int64) * 2)
+    }
+    if (num_bytes == sizeof(int64) * 2) {
       OnScheduleWork(delay_ms[1]);
+    }
   }
 
   if (GetTimeIntervalMilliseconds(delayed_work_time_) == 0) {
diff --git a/tests/shared/browser/main_message_loop_external_pump_win.cc b/tests/shared/browser/main_message_loop_external_pump_win.cc
index ae9535863..36fca5036 100644
--- a/tests/shared/browser/main_message_loop_external_pump_win.cc
+++ b/tests/shared/browser/main_message_loop_external_pump_win.cc
@@ -72,8 +72,9 @@ MainMessageLoopExternalPumpWin::MainMessageLoopExternalPumpWin()
 
 MainMessageLoopExternalPumpWin::~MainMessageLoopExternalPumpWin() {
   KillTimer();
-  if (main_thread_target_)
+  if (main_thread_target_) {
     DestroyWindow(main_thread_target_);
+  }
 }
 
 void MainMessageLoopExternalPumpWin::Quit() {
diff --git a/tests/shared/browser/resource_util_linux.cc b/tests/shared/browser/resource_util_linux.cc
index 7ec263e31..97d69ca48 100644
--- a/tests/shared/browser/resource_util_linux.cc
+++ b/tests/shared/browser/resource_util_linux.cc
@@ -16,15 +16,17 @@ bool GetResourceDir(std::string& dir) {
 
   // Retrieve the executable path.
   ssize_t len = readlink("/proc/self/exe", buff, sizeof(buff) - 1);
-  if (len == -1)
+  if (len == -1) {
     return false;
+  }
 
   buff[len] = 0;
 
   // Remove the executable name from the path.
   char* pos = strrchr(buff, '/');
-  if (!pos)
+  if (!pos) {
     return false;
+  }
 
   // Add "files" to the path.
   strcpy(pos + 1, "files");
diff --git a/tests/shared/browser/resource_util_posix.cc b/tests/shared/browser/resource_util_posix.cc
index 71e73eafb..5c76b40d9 100644
--- a/tests/shared/browser/resource_util_posix.cc
+++ b/tests/shared/browser/resource_util_posix.cc
@@ -22,13 +22,15 @@ bool FileExists(const char* path) {
 bool ReadFileToString(const char* path, std::string& data) {
   // Implementation adapted from base/file_util.cc
   FILE* file = fopen(path, "rb");
-  if (!file)
+  if (!file) {
     return false;
+  }
 
   char buf[1 << 16];
   size_t len;
-  while ((len = fread(buf, 1, sizeof(buf), file)) > 0)
+  while ((len = fread(buf, 1, sizeof(buf), file)) > 0) {
     data.append(buf, len);
+  }
   fclose(file);
 
   return true;
@@ -38,8 +40,9 @@ bool ReadFileToString(const char* path, std::string& data) {
 
 bool LoadBinaryResource(const char* resource_name, std::string& resource_data) {
   std::string path;
-  if (!GetResourceDir(path))
+  if (!GetResourceDir(path)) {
     return false;
+  }
 
   path.append("/");
   path.append(resource_name);
@@ -49,14 +52,16 @@ bool LoadBinaryResource(const char* resource_name, std::string& resource_data) {
 
 CefRefPtr<CefStreamReader> GetBinaryResourceReader(const char* resource_name) {
   std::string path;
-  if (!GetResourceDir(path))
+  if (!GetResourceDir(path)) {
     return nullptr;
+  }
 
   path.append("/");
   path.append(resource_name);
 
-  if (!FileExists(path.c_str()))
+  if (!FileExists(path.c_str())) {
     return nullptr;
+  }
 
   return CefStreamReader::CreateForFile(path);
 }
diff --git a/tests/shared/browser/resource_util_win.cc b/tests/shared/browser/resource_util_win.cc
index 9b8f6c13d..df61ca122 100644
--- a/tests/shared/browser/resource_util_win.cc
+++ b/tests/shared/browser/resource_util_win.cc
@@ -22,8 +22,9 @@ bool LoadBinaryResource(int binaryId, DWORD& dwSize, LPBYTE& pBytes) {
     if (hGlob) {
       dwSize = SizeofResource(hInst, hRes);
       pBytes = (LPBYTE)LockResource(hGlob);
-      if (dwSize > 0 && pBytes)
+      if (dwSize > 0 && pBytes) {
         return true;
+      }
     }
   }
 
@@ -56,8 +57,9 @@ class BinaryResourceProvider : public CefResourceManager::Provider {
 
     std::string relative_path = url.substr(url_path_.length());
     if (!relative_path.empty()) {
-      if (!resource_path_prefix_.empty())
+      if (!resource_path_prefix_.empty()) {
         relative_path = resource_path_prefix_ + relative_path;
+      }
 
       CefRefPtr<CefStreamReader> stream =
           GetBinaryResourceReader(relative_path.data());
@@ -85,8 +87,9 @@ extern int GetResourceId(const char* resource_name);
 
 bool LoadBinaryResource(const char* resource_name, std::string& resource_data) {
   int resource_id = GetResourceId(resource_name);
-  if (resource_id == 0)
+  if (resource_id == 0) {
     return false;
+  }
 
   DWORD dwSize;
   LPBYTE pBytes;
@@ -102,8 +105,9 @@ bool LoadBinaryResource(const char* resource_name, std::string& resource_data) {
 
 CefRefPtr<CefStreamReader> GetBinaryResourceReader(const char* resource_name) {
   int resource_id = GetResourceId(resource_name);
-  if (resource_id == 0)
+  if (resource_id == 0) {
     return nullptr;
+  }
 
   DWORD dwSize;
   LPBYTE pBytes;
diff --git a/tests/shared/browser/util_win.cc b/tests/shared/browser/util_win.cc
index b7f4294f3..4db8201e4 100644
--- a/tests/shared/browser/util_win.cc
+++ b/tests/shared/browser/util_win.cc
@@ -50,46 +50,60 @@ std::wstring GetResourceString(UINT id) {
 
 int GetCefMouseModifiers(WPARAM wparam) {
   int modifiers = 0;
-  if (wparam & MK_CONTROL)
+  if (wparam & MK_CONTROL) {
     modifiers |= EVENTFLAG_CONTROL_DOWN;
-  if (wparam & MK_SHIFT)
+  }
+  if (wparam & MK_SHIFT) {
     modifiers |= EVENTFLAG_SHIFT_DOWN;
-  if (IsKeyDown(VK_MENU))
+  }
+  if (IsKeyDown(VK_MENU)) {
     modifiers |= EVENTFLAG_ALT_DOWN;
-  if (wparam & MK_LBUTTON)
+  }
+  if (wparam & MK_LBUTTON) {
     modifiers |= EVENTFLAG_LEFT_MOUSE_BUTTON;
-  if (wparam & MK_MBUTTON)
+  }
+  if (wparam & MK_MBUTTON) {
     modifiers |= EVENTFLAG_MIDDLE_MOUSE_BUTTON;
-  if (wparam & MK_RBUTTON)
+  }
+  if (wparam & MK_RBUTTON) {
     modifiers |= EVENTFLAG_RIGHT_MOUSE_BUTTON;
+  }
 
   // Low bit set from GetKeyState indicates "toggled".
-  if (::GetKeyState(VK_NUMLOCK) & 1)
+  if (::GetKeyState(VK_NUMLOCK) & 1) {
     modifiers |= EVENTFLAG_NUM_LOCK_ON;
-  if (::GetKeyState(VK_CAPITAL) & 1)
+  }
+  if (::GetKeyState(VK_CAPITAL) & 1) {
     modifiers |= EVENTFLAG_CAPS_LOCK_ON;
+  }
   return modifiers;
 }
 
 int GetCefKeyboardModifiers(WPARAM wparam, LPARAM lparam) {
   int modifiers = 0;
-  if (IsKeyDown(VK_SHIFT))
+  if (IsKeyDown(VK_SHIFT)) {
     modifiers |= EVENTFLAG_SHIFT_DOWN;
-  if (IsKeyDown(VK_CONTROL))
+  }
+  if (IsKeyDown(VK_CONTROL)) {
     modifiers |= EVENTFLAG_CONTROL_DOWN;
-  if (IsKeyDown(VK_MENU))
+  }
+  if (IsKeyDown(VK_MENU)) {
     modifiers |= EVENTFLAG_ALT_DOWN;
+  }
 
   // Low bit set from GetKeyState indicates "toggled".
-  if (::GetKeyState(VK_NUMLOCK) & 1)
+  if (::GetKeyState(VK_NUMLOCK) & 1) {
     modifiers |= EVENTFLAG_NUM_LOCK_ON;
-  if (::GetKeyState(VK_CAPITAL) & 1)
+  }
+  if (::GetKeyState(VK_CAPITAL) & 1) {
     modifiers |= EVENTFLAG_CAPS_LOCK_ON;
+  }
 
   switch (wparam) {
     case VK_RETURN:
-      if ((lparam >> 16) & KF_EXTENDED)
+      if ((lparam >> 16) & KF_EXTENDED) {
         modifiers |= EVENTFLAG_IS_KEY_PAD;
+      }
       break;
     case VK_INSERT:
     case VK_DELETE:
@@ -101,8 +115,9 @@ int GetCefKeyboardModifiers(WPARAM wparam, LPARAM lparam) {
     case VK_DOWN:
     case VK_LEFT:
     case VK_RIGHT:
-      if (!((lparam >> 16) & KF_EXTENDED))
+      if (!((lparam >> 16) & KF_EXTENDED)) {
         modifiers |= EVENTFLAG_IS_KEY_PAD;
+      }
       break;
     case VK_NUMLOCK:
     case VK_NUMPAD0:
@@ -124,22 +139,25 @@ int GetCefKeyboardModifiers(WPARAM wparam, LPARAM lparam) {
       modifiers |= EVENTFLAG_IS_KEY_PAD;
       break;
     case VK_SHIFT:
-      if (IsKeyDown(VK_LSHIFT))
+      if (IsKeyDown(VK_LSHIFT)) {
         modifiers |= EVENTFLAG_IS_LEFT;
-      else if (IsKeyDown(VK_RSHIFT))
+      } else if (IsKeyDown(VK_RSHIFT)) {
         modifiers |= EVENTFLAG_IS_RIGHT;
+      }
       break;
     case VK_CONTROL:
-      if (IsKeyDown(VK_LCONTROL))
+      if (IsKeyDown(VK_LCONTROL)) {
         modifiers |= EVENTFLAG_IS_LEFT;
-      else if (IsKeyDown(VK_RCONTROL))
+      } else if (IsKeyDown(VK_RCONTROL)) {
         modifiers |= EVENTFLAG_IS_RIGHT;
+      }
       break;
     case VK_MENU:
-      if (IsKeyDown(VK_LMENU))
+      if (IsKeyDown(VK_LMENU)) {
         modifiers |= EVENTFLAG_IS_LEFT;
-      else if (IsKeyDown(VK_RMENU))
+      } else if (IsKeyDown(VK_RMENU)) {
         modifiers |= EVENTFLAG_IS_RIGHT;
+      }
       break;
     case VK_LWIN:
       modifiers |= EVENTFLAG_IS_LEFT;
diff --git a/tests/shared/common/client_app.cc b/tests/shared/common/client_app.cc
index 48bb6afb2..76ecde759 100644
--- a/tests/shared/common/client_app.cc
+++ b/tests/shared/common/client_app.cc
@@ -25,15 +25,18 @@ ClientApp::ClientApp() {}
 ClientApp::ProcessType ClientApp::GetProcessType(
     CefRefPtr<CefCommandLine> command_line) {
   // The command-line flag won't be specified for the browser process.
-  if (!command_line->HasSwitch(kProcessType))
+  if (!command_line->HasSwitch(kProcessType)) {
     return BrowserProcess;
+  }
 
   const std::string& process_type = command_line->GetSwitchValue(kProcessType);
-  if (process_type == kRendererProcess)
+  if (process_type == kRendererProcess) {
     return RendererProcess;
+  }
 #if defined(OS_LINUX)
-  else if (process_type == kZygoteProcess)
+  else if (process_type == kZygoteProcess) {
     return ZygoteProcess;
+  }
 #endif
 
   return OtherProcess;
diff --git a/tests/shared/process_helper_mac.cc b/tests/shared/process_helper_mac.cc
index 9efa2e319..cce48e533 100644
--- a/tests/shared/process_helper_mac.cc
+++ b/tests/shared/process_helper_mac.cc
@@ -21,15 +21,17 @@ int RunMain(int argc, char* argv[]) {
 #if defined(CEF_USE_SANDBOX)
   // Initialize the macOS sandbox for this helper process.
   CefScopedSandboxContext sandbox_context;
-  if (!sandbox_context.Initialize(argc, argv))
+  if (!sandbox_context.Initialize(argc, argv)) {
     return 1;
+  }
 #endif
 
   // Load the CEF framework library at runtime instead of linking directly
   // as required by the macOS sandbox implementation.
   CefScopedLibraryLoader library_loader;
-  if (!library_loader.LoadInHelper())
+  if (!library_loader.LoadInHelper()) {
     return 1;
+  }
 
   CefMainArgs main_args(argc, argv);
 
@@ -40,10 +42,11 @@ int RunMain(int argc, char* argv[]) {
   // Create a ClientApp of the correct type.
   CefRefPtr<CefApp> app;
   ClientApp::ProcessType process_type = ClientApp::GetProcessType(command_line);
-  if (process_type == ClientApp::RendererProcess)
+  if (process_type == ClientApp::RendererProcess) {
     app = new ClientAppRenderer();
-  else if (process_type == ClientApp::OtherProcess)
+  } else if (process_type == ClientApp::OtherProcess) {
     app = new ClientAppOther();
+  }
 
   // Execute the secondary process.
   return CefExecuteProcess(main_args, app, nullptr);
diff --git a/tests/shared/renderer/client_app_renderer.cc b/tests/shared/renderer/client_app_renderer.cc
index 216f20b72..9347051aa 100644
--- a/tests/shared/renderer/client_app_renderer.cc
+++ b/tests/shared/renderer/client_app_renderer.cc
@@ -14,29 +14,33 @@ ClientAppRenderer::ClientAppRenderer() {
 
 void ClientAppRenderer::OnWebKitInitialized() {
   DelegateSet::iterator it = delegates_.begin();
-  for (; it != delegates_.end(); ++it)
+  for (; it != delegates_.end(); ++it) {
     (*it)->OnWebKitInitialized(this);
+  }
 }
 
 void ClientAppRenderer::OnBrowserCreated(
     CefRefPtr<CefBrowser> browser,
     CefRefPtr<CefDictionaryValue> extra_info) {
   DelegateSet::iterator it = delegates_.begin();
-  for (; it != delegates_.end(); ++it)
+  for (; it != delegates_.end(); ++it) {
     (*it)->OnBrowserCreated(this, browser, extra_info);
+  }
 }
 
 void ClientAppRenderer::OnBrowserDestroyed(CefRefPtr<CefBrowser> browser) {
   DelegateSet::iterator it = delegates_.begin();
-  for (; it != delegates_.end(); ++it)
+  for (; it != delegates_.end(); ++it) {
     (*it)->OnBrowserDestroyed(this, browser);
+  }
 }
 
 CefRefPtr<CefLoadHandler> ClientAppRenderer::GetLoadHandler() {
   CefRefPtr<CefLoadHandler> load_handler;
   DelegateSet::iterator it = delegates_.begin();
-  for (; it != delegates_.end() && !load_handler.get(); ++it)
+  for (; it != delegates_.end() && !load_handler.get(); ++it) {
     load_handler = (*it)->GetLoadHandler(this);
+  }
 
   return load_handler;
 }
@@ -45,16 +49,18 @@ void ClientAppRenderer::OnContextCreated(CefRefPtr<CefBrowser> browser,
                                          CefRefPtr<CefFrame> frame,
                                          CefRefPtr<CefV8Context> context) {
   DelegateSet::iterator it = delegates_.begin();
-  for (; it != delegates_.end(); ++it)
+  for (; it != delegates_.end(); ++it) {
     (*it)->OnContextCreated(this, browser, frame, context);
+  }
 }
 
 void ClientAppRenderer::OnContextReleased(CefRefPtr<CefBrowser> browser,
                                           CefRefPtr<CefFrame> frame,
                                           CefRefPtr<CefV8Context> context) {
   DelegateSet::iterator it = delegates_.begin();
-  for (; it != delegates_.end(); ++it)
+  for (; it != delegates_.end(); ++it) {
     (*it)->OnContextReleased(this, browser, frame, context);
+  }
 }
 
 void ClientAppRenderer::OnUncaughtException(
@@ -74,8 +80,9 @@ void ClientAppRenderer::OnFocusedNodeChanged(CefRefPtr<CefBrowser> browser,
                                              CefRefPtr<CefFrame> frame,
                                              CefRefPtr<CefDOMNode> node) {
   DelegateSet::iterator it = delegates_.begin();
-  for (; it != delegates_.end(); ++it)
+  for (; it != delegates_.end(); ++it) {
     (*it)->OnFocusedNodeChanged(this, browser, frame, node);
+  }
 }
 
 bool ClientAppRenderer::OnProcessMessageReceived(