Apply clang-format to all C, C++ and ObjC files (issue #2171)

libcef/renderer/browser_impl.cc

@@ -61,7 +61,6 @@ CefRefPtr<CefBrowserImpl> CefBrowserImpl::GetBrowserForMainFrame(
   return CefContentRendererClient::Get()->GetBrowserForMainFrame(frame);
 }
 
-
 // CefBrowser methods.
 // -----------------------------------------------------------------------------
 
@@ -188,8 +187,8 @@ CefRefPtr<CefFrame> CefBrowserImpl::GetFrame(const CefString& name) {
   if (web_view) {
     const blink::WebString& frame_name = blink::WebString::FromUTF16(name);
     // Search by assigned frame name (Frame::name).
-    WebFrame* frame = web_view->FindFrameByName(frame_name,
-                                                web_view->MainFrame());
+    WebFrame* frame =
+        web_view->FindFrameByName(frame_name, web_view->MainFrame());
     if (!frame) {
       // Search by unique frame name (Frame::uniqueName).
       const std::string& searchname = name;
@@ -264,7 +263,6 @@ bool CefBrowserImpl::SendProcessMessage(CefProcessId target_process,
   return false;
 }
 
-
 // CefBrowserImpl public methods.
 // -----------------------------------------------------------------------------
 
@@ -279,8 +277,7 @@ CefBrowserImpl::CefBrowserImpl(content::RenderView* render_view,
   response_manager_.reset(new CefResponseManager);
 }
 
-CefBrowserImpl::~CefBrowserImpl() {
-}
+CefBrowserImpl::~CefBrowserImpl() {}
 
 void CefBrowserImpl::LoadRequest(const CefMsg_LoadRequest_Params& params) {
   CefRefPtr<CefFrameImpl> framePtr = GetWebFrameImpl(params.frame_id);
@@ -327,9 +324,9 @@ CefRefPtr<CefFrameImpl> CefBrowserImpl::GetWebFrameImpl(
   CefRefPtr<CefFrameImpl> framePtr(new CefFrameImpl(this, frame));
   frames_.insert(std::make_pair(frame_id, framePtr));
 
-  const int64_t parent_id = frame->Parent() == NULL ?
-      webkit_glue::kInvalidFrameId :
-      webkit_glue::GetIdentifier(frame->Parent());
+  const int64_t parent_id = frame->Parent() == NULL
+                                ? webkit_glue::kInvalidFrameId
+                                : webkit_glue::GetIdentifier(frame->Parent());
   const base::string16& name =
       base::UTF8ToUTF16(webkit_glue::GetUniqueName(frame));
 
@@ -387,7 +384,6 @@ bool CefBrowserImpl::is_swapped_out() const {
   return (!render_view_impl || render_view_impl->is_swapped_out());
 }
 
-
 // RenderViewObserver methods.
 // -----------------------------------------------------------------------------
 
@@ -395,8 +391,7 @@ void CefBrowserImpl::OnDestruct() {
   // Notify that the browser window has been destroyed.
   CefRefPtr<CefApp> app = CefContentClient::Get()->application();
   if (app.get()) {
-    CefRefPtr<CefRenderProcessHandler> handler =
-        app->GetRenderProcessHandler();
+    CefRefPtr<CefRenderProcessHandler> handler = app->GetRenderProcessHandler();
     if (handler.get())
       handler->OnBrowserDestroyed(this);
   }
@@ -414,20 +409,17 @@ void CefBrowserImpl::DidStopLoading() {
   OnLoadingStateChange(false);
 }
 
-void CefBrowserImpl::DidFailLoad(
-    blink::WebLocalFrame* frame,
-    const blink::WebURLError& error) {
+void CefBrowserImpl::DidFailLoad(blink::WebLocalFrame* frame,
+                                 const blink::WebURLError& error) {
   OnLoadError(frame, error);
   OnLoadEnd(frame);
 }
 
 void CefBrowserImpl::DidFinishLoad(blink::WebLocalFrame* frame) {
   blink::WebDataSource* ds = frame->DataSource();
-  Send(new CefHostMsg_DidFinishLoad(routing_id(),
-                                    webkit_glue::GetIdentifier(frame),
-                                    ds->GetRequest().Url(),
-                                    !frame->Parent(),
-                                    ds->GetResponse().HttpStatusCode()));
+  Send(new CefHostMsg_DidFinishLoad(
+      routing_id(), webkit_glue::GetIdentifier(frame), ds->GetRequest().Url(),
+      !frame->Parent(), ds->GetResponse().HttpStatusCode()));
   OnLoadEnd(frame);
 }
 
@@ -436,9 +428,8 @@ void CefBrowserImpl::DidStartProvisionalLoad(blink::WebLocalFrame* frame) {
   GetWebFrameImpl(frame);
 }
 
-void CefBrowserImpl::DidFailProvisionalLoad(
-    blink::WebLocalFrame* frame,
-    const blink::WebURLError& error) {
+void CefBrowserImpl::DidFailProvisionalLoad(blink::WebLocalFrame* frame,
+                                            const blink::WebURLError& error) {
   OnLoadError(frame, error);
 }
 
@@ -471,8 +462,7 @@ void CefBrowserImpl::FocusedNodeChanged(const blink::WebNode& node) {
   // Notify the handler.
   CefRefPtr<CefApp> app = CefContentClient::Get()->application();
   if (app.get()) {
-    CefRefPtr<CefRenderProcessHandler> handler =
-        app->GetRenderProcessHandler();
+    CefRefPtr<CefRenderProcessHandler> handler = app->GetRenderProcessHandler();
     if (handler.get()) {
       if (node.IsNull()) {
         handler->OnFocusedNodeChanged(this, GetFocusedFrame(), NULL);
@@ -482,9 +472,8 @@ void CefBrowserImpl::FocusedNodeChanged(const blink::WebNode& node) {
           blink::WebFrame* frame = document.GetFrame();
           CefRefPtr<CefDOMDocumentImpl> documentImpl =
               new CefDOMDocumentImpl(this, frame);
-          handler->OnFocusedNodeChanged(this,
-              GetWebFrameImpl(frame).get(),
-              documentImpl->GetOrCreateNode(node));
+          handler->OnFocusedNodeChanged(this, GetWebFrameImpl(frame).get(),
+                                        documentImpl->GetOrCreateNode(node));
           documentImpl->Detach();
         }
       }
@@ -519,7 +508,6 @@ bool CefBrowserImpl::OnMessageReceived(const IPC::Message& message) {
   return handled;
 }
 
-
 // RenderViewObserver::OnMessageReceived message handlers.
 // -----------------------------------------------------------------------------
 
@@ -528,9 +516,9 @@ void CefBrowserImpl::OnRequest(const Cef_Request_Params& params) {
   std::string response;
   bool expect_response_ack = false;
 
-  TRACE_EVENT2("libcef", "CefBrowserImpl::OnRequest",
-               "request_id", params.request_id,
-               "expect_response", params.expect_response ? 1 : 0);
+  TRACE_EVENT2("libcef", "CefBrowserImpl::OnRequest", "request_id",
+               params.request_id, "expect_response",
+               params.expect_response ? 1 : 0);
 
   if (params.user_initiated) {
     // Give the user a chance to handle the request.
@@ -539,11 +527,10 @@ void CefBrowserImpl::OnRequest(const Cef_Request_Params& params) {
       CefRefPtr<CefRenderProcessHandler> handler =
           app->GetRenderProcessHandler();
       if (handler.get()) {
-        CefRefPtr<CefProcessMessageImpl> message(
-            new CefProcessMessageImpl(const_cast<Cef_Request_Params*>(&params),
-                                      false, true));
-        success = handler->OnProcessMessageReceived(this, PID_BROWSER,
-                                                    message.get());
+        CefRefPtr<CefProcessMessageImpl> message(new CefProcessMessageImpl(
+            const_cast<Cef_Request_Params*>(&params), false, true));
+        success =
+            handler->OnProcessMessageReceived(this, PID_BROWSER, message.get());
         message->Detach(nullptr);
       }
     }
@@ -569,8 +556,7 @@ void CefBrowserImpl::OnRequest(const Cef_Request_Params& params) {
         if (is_javascript) {
           web_frame->ExecuteScript(
               WebScriptSource(blink::WebString::FromUTF8(code),
-                              GURL(script_url),
-                              script_start_line));
+                              GURL(script_url), script_start_line));
           success = true;
         } else {
           // TODO(cef): implement support for CSS code.
@@ -594,7 +580,8 @@ void CefBrowserImpl::OnRequest(const Cef_Request_Params& params) {
         if (base::LowerCaseEqualsASCII(command, "getsource")) {
           if (web_frame->IsWebLocalFrame()) {
             response = blink::WebFrameContentDumper::DumpAsMarkup(
-                web_frame->ToWebLocalFrame()).Utf8();
+                           web_frame->ToWebLocalFrame())
+                           .Utf8();
             success = true;
           }
         } else if (base::LowerCaseEqualsASCII(command, "gettext")) {
@@ -602,7 +589,7 @@ void CefBrowserImpl::OnRequest(const Cef_Request_Params& params) {
           success = true;
         } else if (web_frame->IsWebLocalFrame() &&
                    web_frame->ToWebLocalFrame()->ExecuteCommand(
-                      blink::WebString::FromUTF8(command))) {
+                       blink::WebString::FromUTF8(command))) {
           success = true;
         }
       }
@@ -657,8 +644,7 @@ void CefBrowserImpl::OnLoadingStateChange(bool isLoading) {
 
   CefRefPtr<CefApp> app = CefContentClient::Get()->application();
   if (app.get()) {
-    CefRefPtr<CefRenderProcessHandler> handler =
-        app->GetRenderProcessHandler();
+    CefRefPtr<CefRenderProcessHandler> handler = app->GetRenderProcessHandler();
     if (handler.get()) {
       CefRefPtr<CefLoadHandler> load_handler = handler->GetLoadHandler();
       if (load_handler.get()) {
@@ -679,8 +665,7 @@ void CefBrowserImpl::OnLoadStart(blink::WebLocalFrame* frame) {
 
   CefRefPtr<CefApp> app = CefContentClient::Get()->application();
   if (app.get()) {
-    CefRefPtr<CefRenderProcessHandler> handler =
-        app->GetRenderProcessHandler();
+    CefRefPtr<CefRenderProcessHandler> handler = app->GetRenderProcessHandler();
     if (handler.get()) {
       CefRefPtr<CefLoadHandler> load_handler = handler->GetLoadHandler();
       if (load_handler.get()) {
@@ -697,8 +682,7 @@ void CefBrowserImpl::OnLoadEnd(blink::WebLocalFrame* frame) {
 
   CefRefPtr<CefApp> app = CefContentClient::Get()->application();
   if (app.get()) {
-    CefRefPtr<CefRenderProcessHandler> handler =
-        app->GetRenderProcessHandler();
+    CefRefPtr<CefRenderProcessHandler> handler = app->GetRenderProcessHandler();
     if (handler.get()) {
       CefRefPtr<CefLoadHandler> load_handler = handler->GetLoadHandler();
       if (load_handler.get()) {
@@ -718,8 +702,7 @@ void CefBrowserImpl::OnLoadError(blink::WebLocalFrame* frame,
 
   CefRefPtr<CefApp> app = CefContentClient::Get()->application();
   if (app.get()) {
-    CefRefPtr<CefRenderProcessHandler> handler =
-        app->GetRenderProcessHandler();
+    CefRefPtr<CefRenderProcessHandler> handler = app->GetRenderProcessHandler();
     if (handler.get()) {
       CefRefPtr<CefLoadHandler> load_handler = handler->GetLoadHandler();
       if (load_handler.get()) {

libcef/renderer/browser_impl.h

@@ -40,8 +40,7 @@ class ListValue;
 // RenderViewObserver implementation. IPC messages sent using
 // RenderViewObserver::Send() will be forwarded to the RenderView. Use
 // RenderViewObserver::routing_id() when sending IPC messages.
-class CefBrowserImpl : public CefBrowser,
-                       public content::RenderViewObserver {
+class CefBrowserImpl : public CefBrowser, public content::RenderViewObserver {
  public:
   // Returns the browser associated with the specified RenderView.
   static CefRefPtr<CefBrowserImpl> GetBrowserForView(content::RenderView* view);
@@ -70,9 +69,8 @@ class CefBrowserImpl : public CefBrowser,
   size_t GetFrameCount() override;
   void GetFrameIdentifiers(std::vector<int64>& identifiers) override;
   void GetFrameNames(std::vector<CefString>& names) override;
-  bool SendProcessMessage(
-      CefProcessId target_process,
-      CefRefPtr<CefProcessMessage> message) override;
+  bool SendProcessMessage(CefProcessId target_process,
+                          CefRefPtr<CefProcessMessage> message) override;
 
   CefBrowserImpl(content::RenderView* render_view,
                  int browser_id,
@@ -113,9 +111,8 @@ class CefBrowserImpl : public CefBrowser,
                    const blink::WebURLError& error) override;
   void DidFinishLoad(blink::WebLocalFrame* frame) override;
   void DidStartProvisionalLoad(blink::WebLocalFrame* frame) override;
-  void DidFailProvisionalLoad(
-      blink::WebLocalFrame* frame,
-      const blink::WebURLError& error) override;
+  void DidFailProvisionalLoad(blink::WebLocalFrame* frame,
+                              const blink::WebURLError& error) override;
   void DidCommitProvisionalLoad(blink::WebLocalFrame* frame,
                                 bool is_new_navigation) override;
   void FrameDetached(blink::WebFrame* frame) override;
@@ -142,12 +139,12 @@ class CefBrowserImpl : public CefBrowser,
   bool is_windowless_;
 
   // Map of unique frame ids to CefFrameImpl references.
-  typedef std::map<int64, CefRefPtr<CefFrameImpl> > FrameMap;
+  typedef std::map<int64, CefRefPtr<CefFrameImpl>> FrameMap;
   FrameMap frames_;
 
   // Map of unique frame ids to CefTrackManager objects that need to be cleaned
   // up when the frame is deleted.
-  typedef std::map<int64, CefRefPtr<CefTrackManager> > FrameObjectMap;
+  typedef std::map<int64, CefRefPtr<CefTrackManager>> FrameObjectMap;
   FrameObjectMap frame_objects_;
 
   // Manages response registrations.

libcef/renderer/content_renderer_client.cc

@@ -12,7 +12,7 @@
 // Enable deprecation warnings for MSVC. See http://crbug.com/585142.
 #if defined(OS_WIN)
 #pragma warning(push)
-#pragma warning(default:4996)
+#pragma warning(default : 4996)
 #endif
 
 #include "libcef/browser/context.h"
@@ -123,9 +123,7 @@ class CefPrerendererClient : public content::RenderViewObserver,
   ~CefPrerendererClient() override {}
 
   // RenderViewObserver methods:
-  void OnDestruct() override {
-    delete this;
-  }
+  void OnDestruct() override { delete this; }
 
   // WebPrerendererClient methods:
   void WillAddPrerender(blink::WebPrerender* prerender) override {}
@@ -166,8 +164,7 @@ void AppendParams(const std::vector<base::string16>& additional_names,
 class CefGuestView : public content::RenderViewObserver {
  public:
   explicit CefGuestView(content::RenderView* render_view)
-      : content::RenderViewObserver(render_view) {
-  }
+      : content::RenderViewObserver(render_view) {}
 
  private:
   // RenderViewObserver methods.
@@ -192,8 +189,7 @@ CefContentRendererClient::CefContentRendererClient()
   printing::SetAgent(CefContentClient::Get()->GetUserAgent());
 }
 
-CefContentRendererClient::~CefContentRendererClient() {
-}
+CefContentRendererClient::~CefContentRendererClient() {}
 
 // static
 CefContentRendererClient* CefContentRendererClient::Get() {
@@ -240,8 +236,7 @@ void CefContentRendererClient::OnBrowserDestroyed(CefBrowserImpl* browser) {
   NOTREACHED();
 }
 
-bool CefContentRendererClient::HasGuestViewForView(
-    content::RenderView* view) {
+bool CefContentRendererClient::HasGuestViewForView(content::RenderView* view) {
   CEF_REQUIRE_RT_RETURN(false);
 
   GuestViewMap::const_iterator it = guest_views_.find(view);
@@ -299,8 +294,7 @@ void CefContentRendererClient::WebKitInitialized() {
           cross_origin_whitelist_entries_[i];
       GURL gurl = GURL(entry.source_origin);
       blink::WebSecurityPolicy::AddOriginAccessWhitelistEntry(
-          gurl,
-          blink::WebString::FromUTF8(entry.target_protocol),
+          gurl, blink::WebString::FromUTF8(entry.target_protocol),
           blink::WebString::FromUTF8(entry.target_domain),
           entry.allow_target_subdomains);
     }
@@ -310,10 +304,9 @@ void CefContentRendererClient::WebKitInitialized() {
   // The number of stack trace frames to capture for uncaught exceptions.
   if (command_line->HasSwitch(switches::kUncaughtExceptionStackSize)) {
     int uncaught_exception_stack_size = 0;
-    base::StringToInt(
-        command_line->GetSwitchValueASCII(
-            switches::kUncaughtExceptionStackSize),
-        &uncaught_exception_stack_size);
+    base::StringToInt(command_line->GetSwitchValueASCII(
+                          switches::kUncaughtExceptionStackSize),
+                      &uncaught_exception_stack_size);
 
     if (uncaught_exception_stack_size > 0) {
       uncaught_exception_stack_size_ = uncaught_exception_stack_size;
@@ -352,7 +345,7 @@ void CefContentRendererClient::DevToolsAgentDetached() {
 }
 
 scoped_refptr<base::SequencedTaskRunner>
-    CefContentRendererClient::GetCurrentTaskRunner() {
+CefContentRendererClient::GetCurrentTaskRunner() {
   // Check if currently on the render thread.
   if (CEF_CURRENTLY_ON_RT())
     return render_task_runner_;
@@ -369,7 +362,8 @@ void CefContentRendererClient::RunSingleProcessCleanup() {
   if (content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
     RunSingleProcessCleanupOnUIThread();
   } else {
-    content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
+    content::BrowserThread::PostTask(
+        content::BrowserThread::UI, FROM_HERE,
         base::Bind(&CefContentRendererClient::RunSingleProcessCleanupOnUIThread,
                    base::Unretained(this)));
   }
@@ -452,7 +446,7 @@ void CefContentRendererClient::RenderThreadStarted() {
         application->GetRenderProcessHandler();
     if (handler.get()) {
       CefRefPtr<CefListValueImpl> listValuePtr(
-        new CefListValueImpl(&params.extra_info, false, true));
+          new CefListValueImpl(&params.extra_info, false, true));
       handler->OnRenderThreadCreated(listValuePtr.get());
       listValuePtr->Detach(NULL);
     }
@@ -623,7 +617,8 @@ bool CefContentRendererClient::WillSendRequest(
 }
 
 unsigned long long CefContentRendererClient::VisitedLinkHash(
-    const char* canonical_url, size_t length) {
+    const char* canonical_url,
+    size_t length) {
   return observer_->visited_link_slave()->ComputeURLFingerprint(canonical_url,
                                                                 length);
 }
@@ -639,7 +634,7 @@ CefContentRendererClient::CreateBrowserPluginDelegate(
     const GURL& original_url) {
   DCHECK(extensions::ExtensionsEnabled());
   return extensions::CefExtensionsRendererClient::CreateBrowserPluginDelegate(
-       render_frame, mime_type, original_url);
+      render_frame, mime_type, original_url);
 }
 
 void CefContentRendererClient::AddSupportedKeySystems(
@@ -711,13 +706,13 @@ blink::WebPlugin* CefContentRendererClient::CreatePlugin(
       params.mime_type = blink::WebString::FromUTF8(actual_mime_type);
     }
 
-    auto create_blocked_plugin = [&render_frame, &frame, &params, &info,
-                                  &identifier, &group_name](
-        int template_id, const base::string16& message) {
-      return CefPluginPlaceholder::CreateBlockedPlugin(
-          render_frame, frame, params, info, identifier, group_name,
-          template_id, message, PowerSaverInfo());
-    };
+    auto create_blocked_plugin =
+        [&render_frame, &frame, &params, &info, &identifier, &group_name](
+            int template_id, const base::string16& message) {
+          return CefPluginPlaceholder::CreateBlockedPlugin(
+              render_frame, frame, params, info, identifier, group_name,
+              template_id, message, PowerSaverInfo());
+        };
     switch (status) {
       case CefViewHostMsg_GetPluginInfo_Status::kNotFound: {
         NOTREACHED();
@@ -843,11 +838,8 @@ void CefContentRendererClient::BrowserCreated(
   // Retrieve the browser information synchronously. This will also register
   // the routing ids with the browser info object in the browser process.
   CefProcessHostMsg_GetNewBrowserInfo_Params params;
-  content::RenderThread::Get()->Send(
-      new CefProcessHostMsg_GetNewBrowserInfo(
-          render_view_routing_id,
-          render_frame_routing_id,
-          &params));
+  content::RenderThread::Get()->Send(new CefProcessHostMsg_GetNewBrowserInfo(
+      render_view_routing_id, render_frame_routing_id, &params));
   if (params.browser_id == 0) {
     // The popup may have been canceled during creation.
     return;
@@ -855,9 +847,8 @@ void CefContentRendererClient::BrowserCreated(
 
   if (params.is_guest_view) {
     // Don't create a CefBrowser for guest views.
-    guest_views_.insert(
-        std::make_pair(render_view,
-                       base::MakeUnique<CefGuestView>(render_view)));
+    guest_views_.insert(std::make_pair(
+        render_view, base::MakeUnique<CefGuestView>(render_view)));
     return;
   }
 
@@ -870,9 +861,8 @@ void CefContentRendererClient::BrowserCreated(
       !params.is_windowless);
 #endif
 
-  CefRefPtr<CefBrowserImpl> browser =
-      new CefBrowserImpl(render_view, params.browser_id, params.is_popup,
-                         params.is_windowless);
+  CefRefPtr<CefBrowserImpl> browser = new CefBrowserImpl(
+      render_view, params.browser_id, params.is_popup, params.is_windowless);
   browsers_.insert(std::make_pair(render_view, browser));
 
   // Notify the render process handler.
@@ -914,7 +904,6 @@ void CefContentRendererClient::RunSingleProcessCleanupOnUIThread() {
     delete host;
 }
 
-
 // Enable deprecation warnings for MSVC. See http://crbug.com/585142.
 #if defined(OS_WIN)
 #pragma warning(pop)

libcef/renderer/content_renderer_client.h

@@ -92,11 +92,10 @@ class CefContentRendererClient : public content::ContentRendererClient,
   void RenderThreadStarted() override;
   void RenderFrameCreated(content::RenderFrame* render_frame) override;
   void RenderViewCreated(content::RenderView* render_view) override;
-  bool OverrideCreatePlugin(
-      content::RenderFrame* render_frame,
-      blink::WebLocalFrame* frame,
-      const blink::WebPluginParams& params,
-      blink::WebPlugin** plugin) override;
+  bool OverrideCreatePlugin(content::RenderFrame* render_frame,
+                            blink::WebLocalFrame* frame,
+                            const blink::WebPluginParams& params,
+                            blink::WebPlugin** plugin) override;
   bool HandleNavigation(content::RenderFrame* render_frame,
                         bool is_content_initiated,
                         bool render_view_was_created_by_renderer,
@@ -151,11 +150,11 @@ class CefContentRendererClient : public content::ContentRendererClient,
   std::unique_ptr<SpellCheck> spellcheck_;
 
   // Map of RenderView pointers to CefBrowserImpl references.
-  typedef std::map<content::RenderView*, CefRefPtr<CefBrowserImpl> > BrowserMap;
+  typedef std::map<content::RenderView*, CefRefPtr<CefBrowserImpl>> BrowserMap;
   BrowserMap browsers_;
 
   // Map of RenderView poiners to CefGuestView implementations.
-  typedef std::map<content::RenderView*, std::unique_ptr<CefGuestView> >
+  typedef std::map<content::RenderView*, std::unique_ptr<CefGuestView>>
       GuestViewMap;
   GuestViewMap guest_views_;
 

libcef/renderer/dom_document_impl.cc

@@ -24,11 +24,8 @@ using blink::WebRange;
 using blink::WebString;
 using blink::WebURL;
 
-
-CefDOMDocumentImpl::CefDOMDocumentImpl(CefBrowserImpl* browser,
-                                       WebFrame* frame)
-    : browser_(browser),
-      frame_(frame) {
+CefDOMDocumentImpl::CefDOMDocumentImpl(CefBrowserImpl* browser, WebFrame* frame)
+    : browser_(browser), frame_(frame) {
   const WebDocument& document = frame_->GetDocument();
   DCHECK(!document.IsNull());
 }

libcef/renderer/dom_document_impl.h

@@ -18,8 +18,7 @@ class CefBrowserImpl;
 
 class CefDOMDocumentImpl : public CefDOMDocument {
  public:
-  CefDOMDocumentImpl(CefBrowserImpl* browser,
-                     blink::WebFrame* frame);
+  CefDOMDocumentImpl(CefBrowserImpl* browser, blink::WebFrame* frame);
   ~CefDOMDocumentImpl() override;
 
   // CefDOMDocument methods.

libcef/renderer/dom_node_impl.cc

@@ -3,6 +3,7 @@
 // can be found in the LICENSE file.
 
 #include "libcef/renderer/dom_node_impl.h"
+
 #include "libcef/common/tracker.h"
 #include "libcef/renderer/browser_impl.h"
 #include "libcef/renderer/dom_document_impl.h"
@@ -13,11 +14,11 @@
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "third_party/WebKit/public/platform/WebString.h"
-#include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebDOMEvent.h"
+#include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
-#include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebFormControlElement.h"
+#include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebInputElement.h"
 #include "third_party/WebKit/public/web/WebNode.h"
 #include "third_party/WebKit/public/web/WebSelectElement.h"
@@ -34,9 +35,7 @@ using blink::WebString;
 
 CefDOMNodeImpl::CefDOMNodeImpl(CefRefPtr<CefDOMDocumentImpl> document,
                                const blink::WebNode& node)
-    : document_(document),
-      node_(node) {
-}
+    : document_(document), node_(node) {}
 
 CefDOMNodeImpl::~CefDOMNodeImpl() {
   CEF_REQUIRE_RT();

libcef/renderer/extensions/extensions_dispatcher_delegate.cc

@@ -6,10 +6,8 @@
 
 namespace extensions {
 
-CefExtensionsDispatcherDelegate::CefExtensionsDispatcherDelegate() {
-}
+CefExtensionsDispatcherDelegate::CefExtensionsDispatcherDelegate() {}
 
-CefExtensionsDispatcherDelegate::~CefExtensionsDispatcherDelegate() {
-}
+CefExtensionsDispatcherDelegate::~CefExtensionsDispatcherDelegate() {}
 
 }  // namespace extensions

libcef/renderer/extensions/extensions_renderer_client.cc

@@ -85,9 +85,9 @@ bool CrossesExtensionExtents(blink::WebLocalFrame* frame,
     blink::WebDocument opener_document = opener_frame->GetDocument();
     blink::WebSecurityOrigin opener_origin =
         opener_document.GetSecurityOrigin();
-    bool opener_is_extension_url = !opener_origin.IsUnique() &&
-                                   extension_registry->GetExtensionOrAppByURL(
-                                       opener_document.Url()) != nullptr;
+    bool opener_is_extension_url =
+        !opener_origin.IsUnique() && extension_registry->GetExtensionOrAppByURL(
+                                         opener_document.Url()) != nullptr;
     const extensions::Extension* opener_top_extension =
         extension_registry->GetExtensionOrAppByURL(old_url);
     bool opener_is_web_store =
@@ -111,11 +111,9 @@ bool CrossesExtensionExtents(blink::WebLocalFrame* frame,
 
 }  // namespace
 
-CefExtensionsRendererClient::CefExtensionsRendererClient() {
-}
+CefExtensionsRendererClient::CefExtensionsRendererClient() {}
 
-CefExtensionsRendererClient::~CefExtensionsRendererClient() {
-}
+CefExtensionsRendererClient::~CefExtensionsRendererClient() {}
 
 bool CefExtensionsRendererClient::IsIncognitoProcess() const {
   return CefRenderThreadObserver::is_incognito_process();
@@ -135,7 +133,7 @@ void CefExtensionsRendererClient::RenderThreadStarted() {
   extension_dispatcher_.reset(
       new extensions::Dispatcher(extension_dispatcher_delegate_.get()));
   resource_request_policy_.reset(
-    new extensions::ResourceRequestPolicy(extension_dispatcher_.get()));
+      new extensions::ResourceRequestPolicy(extension_dispatcher_.get()));
   guest_view_container_dispatcher_.reset(
       new extensions::ExtensionsGuestViewContainerDispatcher());
 
@@ -238,7 +236,7 @@ bool CefExtensionsRendererClient::ShouldFork(blink::WebLocalFrame* frame,
   // for subframes, so this check only makes sense for top-level frames.
   // TODO(alexmos,nasko): Figure out how this check should work when reloading
   // subframes in --site-per-process mode.
-  if (!frame->Parent() &&  GURL(frame->GetDocument().Url()) == url) {
+  if (!frame->Parent() && GURL(frame->GetDocument().Url()) == url) {
     if (is_extension_url != IsStandaloneExtensionProcess())
       return true;
   }

libcef/renderer/extensions/extensions_renderer_client.h

@@ -68,7 +68,8 @@ class CefExtensionsRendererClient : public ExtensionsRendererClient {
       const GURL& original_url);
 
  private:
-  std::unique_ptr<extensions::DispatcherDelegate> extension_dispatcher_delegate_;
+  std::unique_ptr<extensions::DispatcherDelegate>
+      extension_dispatcher_delegate_;
   std::unique_ptr<extensions::Dispatcher> extension_dispatcher_;
   std::unique_ptr<extensions::ExtensionsGuestViewContainerDispatcher>
       guest_view_container_dispatcher_;

libcef/renderer/extensions/print_web_view_helper_delegate.cc

@@ -18,8 +18,7 @@
 
 namespace extensions {
 
-CefPrintWebViewHelperDelegate::~CefPrintWebViewHelperDelegate(){
-}
+CefPrintWebViewHelperDelegate::~CefPrintWebViewHelperDelegate() {}
 
 bool CefPrintWebViewHelperDelegate::CancelPrerender(
     content::RenderFrame* render_frame) {
@@ -28,7 +27,7 @@ bool CefPrintWebViewHelperDelegate::CancelPrerender(
 
 // Return the PDF object element if |frame| is the out of process PDF extension.
 blink::WebElement CefPrintWebViewHelperDelegate::GetPdfElement(
-        blink::WebLocalFrame* frame) {
+    blink::WebLocalFrame* frame) {
   GURL url = frame->GetDocument().Url();
   if (url.SchemeIs(extensions::kExtensionScheme) &&
       url.host() == extension_misc::kPdfExtensionId) {
@@ -47,8 +46,7 @@ bool CefPrintWebViewHelperDelegate::IsPrintPreviewEnabled() {
   return false;
 }
 
-bool CefPrintWebViewHelperDelegate::OverridePrint(
-    blink::WebLocalFrame* frame) {
+bool CefPrintWebViewHelperDelegate::OverridePrint(blink::WebLocalFrame* frame) {
   if (!frame->GetDocument().IsPluginDocument())
     return false;
 

libcef/renderer/frame_impl.cc

@@ -9,7 +9,7 @@
 // Enable deprecation warnings for MSVC. See http://crbug.com/585142.
 #if defined(OS_WIN)
 #pragma warning(push)
-#pragma warning(default:4996)
+#pragma warning(default : 4996)
 #endif
 
 #include "libcef/common/cef_messages.h"
@@ -29,20 +29,17 @@
 #include "third_party/WebKit/public/web/WebFrameContentDumper.h"
 #include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
-#include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/WebKit/public/web/WebScriptSource.h"
+#include "third_party/WebKit/public/web/WebView.h"
 
 using blink::WebString;
 
-CefFrameImpl::CefFrameImpl(CefBrowserImpl* browser,
-                           blink::WebFrame* frame)
-  : browser_(browser),
-    frame_(frame),
-    frame_id_(webkit_glue::GetIdentifier(frame)) {
-}
+CefFrameImpl::CefFrameImpl(CefBrowserImpl* browser, blink::WebFrame* frame)
+    : browser_(browser),
+      frame_(frame),
+      frame_id_(webkit_glue::GetIdentifier(frame)) {}
 
-CefFrameImpl::~CefFrameImpl() {
-}
+CefFrameImpl::~CefFrameImpl() {}
 
 bool CefFrameImpl::IsValid() {
   CEF_REQUIRE_RT_RETURN(false);
@@ -85,9 +82,9 @@ void CefFrameImpl::ViewSource() {
 void CefFrameImpl::GetSource(CefRefPtr<CefStringVisitor> visitor) {
   CEF_REQUIRE_RT_RETURN_VOID();
   if (frame_ && frame_->IsWebLocalFrame()) {
-    const CefString& content =
-        std::string(blink::WebFrameContentDumper::DumpAsMarkup(
-            frame_->ToWebLocalFrame()).Utf8());
+    const CefString& content = std::string(
+        blink::WebFrameContentDumper::DumpAsMarkup(frame_->ToWebLocalFrame())
+            .Utf8());
     visitor->Visit(content);
   }
 }
@@ -141,12 +138,11 @@ void CefFrameImpl::LoadURL(const CefString& url) {
   params.url = GURL(url.ToString());
   params.method = "GET";
   params.frame_id = frame_id_;
-  
+
   browser_->LoadRequest(params);
 }
 
-void CefFrameImpl::LoadString(const CefString& string,
-                              const CefString& url) {
+void CefFrameImpl::LoadString(const CefString& string, const CefString& url) {
   CEF_REQUIRE_RT_RETURN_VOID();
 
   if (frame_) {
@@ -167,9 +163,8 @@ void CefFrameImpl::ExecuteJavaScript(const CefString& jsCode,
 
   if (frame_) {
     GURL gurl = GURL(scriptUrl.ToString());
-    frame_->ExecuteScript(
-        blink::WebScriptSource(WebString::FromUTF16(jsCode.ToString16()), gurl,
-                               startLine));
+    frame_->ExecuteScript(blink::WebScriptSource(
+        WebString::FromUTF16(jsCode.ToString16()), gurl, startLine));
   }
 }
 
@@ -275,7 +270,6 @@ void CefFrameImpl::ExecuteCommand(const std::string& command) {
     frame_->ToWebLocalFrame()->ExecuteCommand(WebString::FromUTF8(command));
 }
 
-
 // Enable deprecation warnings for MSVC. See http://crbug.com/585142.
 #if defined(OS_WIN)
 #pragma warning(pop)

libcef/renderer/frame_impl.h

@@ -21,8 +21,7 @@ class WebFrame;
 // associated renderer WebFrame will close.
 class CefFrameImpl : public CefFrame {
  public:
-  CefFrameImpl(CefBrowserImpl* browser,
-               blink::WebFrame* frame);
+  CefFrameImpl(CefBrowserImpl* browser, blink::WebFrame* frame);
   ~CefFrameImpl() override;
 
   // CefFrame implementation.
@@ -39,8 +38,7 @@ class CefFrameImpl : public CefFrame {
   void GetText(CefRefPtr<CefStringVisitor> visitor) override;
   void LoadRequest(CefRefPtr<CefRequest> request) override;
   void LoadURL(const CefString& url) override;
-  void LoadString(const CefString& string,
-                  const CefString& url) override;
+  void LoadString(const CefString& string, const CefString& url) override;
   void ExecuteJavaScript(const CefString& jsCode,
                          const CefString& scriptUrl,
                          int startLine) override;

libcef/renderer/media/cef_key_systems.cc

@@ -19,7 +19,7 @@
 #include "media/media_features.h"
 #include "ppapi/features/features.h"
 
-#include "widevine_cdm_version.h" // In SHARED_INTERMEDIATE_DIR.
+#include "widevine_cdm_version.h"  // In SHARED_INTERMEDIATE_DIR.
 
 // The following must be after widevine_cdm_version.h.
 
@@ -41,9 +41,7 @@ bool IsPepperCdmAvailable(
   bool is_available = false;
   content::RenderThread::Get()->Send(
       new CefViewHostMsg_IsInternalPluginAvailableForMimeType(
-          pepper_type,
-          &is_available,
-          additional_param_names,
+          pepper_type, &is_available, additional_param_names,
           additional_param_values));
 
   return is_available;
@@ -64,8 +62,7 @@ void GetSupportedCodecsForPepperCdm(
         base::ASCIIToUTF16(kCdmSupportedCodecsParamName)) {
       const base::string16& codecs_string16 = additional_param_values[i];
       std::string codecs_string;
-      if (!base::UTF16ToUTF8(codecs_string16.c_str(),
-                             codecs_string16.length(),
+      if (!base::UTF16ToUTF8(codecs_string16.c_str(), codecs_string16.length(),
                              &codecs_string)) {
         DLOG(WARNING) << "Non-UTF-8 codecs string.";
         // Continue using the best effort conversion.
@@ -89,8 +86,7 @@ void AddPepperBasedWidevine(
 
   std::vector<base::string16> additional_param_names;
   std::vector<base::string16> additional_param_values;
-  if (!IsPepperCdmAvailable(kWidevineCdmPluginMimeType,
-                            &additional_param_names,
+  if (!IsPepperCdmAvailable(kWidevineCdmPluginMimeType, &additional_param_names,
                             &additional_param_values)) {
     DVLOG(1) << "Widevine CDM is not currently available.";
     return;
@@ -98,8 +94,7 @@ void AddPepperBasedWidevine(
 
   std::vector<std::string> codecs;
   GetSupportedCodecsForPepperCdm(additional_param_names,
-                                 additional_param_values,
-                                 &codecs);
+                                 additional_param_values, &codecs);
 
   SupportedCodecs supported_codecs = media::EME_CODEC_NONE;
 

libcef/renderer/media/cef_key_systems.h

@@ -13,8 +13,7 @@ class KeySystemProperties;
 }
 
 // Register the key systems supported by populating |key_systems_properties|.
-void AddCefKeySystems(
-    std::vector<std::unique_ptr<media::KeySystemProperties>>*
-        key_systems_properties);
+void AddCefKeySystems(std::vector<std::unique_ptr<media::KeySystemProperties>>*
+                          key_systems_properties);
 
 #endif  // CEF_LIBCEF_RENDERER_MEDIA_CEF_KEY_SYSTEMS_H_

libcef/renderer/plugins/cef_plugin_placeholder.cc

@@ -45,15 +45,13 @@ namespace {
 const CefPluginPlaceholder* g_last_active_menu = NULL;
 }  // namespace
 
-gin::WrapperInfo CefPluginPlaceholder::kWrapperInfo = {
-    gin::kEmbedderNativeGin};
+gin::WrapperInfo CefPluginPlaceholder::kWrapperInfo = {gin::kEmbedderNativeGin};
 
-CefPluginPlaceholder::CefPluginPlaceholder(
-    content::RenderFrame* render_frame,
-    blink::WebLocalFrame* frame,
-    const blink::WebPluginParams& params,
-    const std::string& html_data,
-    const base::string16& title)
+CefPluginPlaceholder::CefPluginPlaceholder(content::RenderFrame* render_frame,
+                                           blink::WebLocalFrame* frame,
+                                           const blink::WebPluginParams& params,
+                                           const std::string& html_data,
+                                           const base::string16& title)
     : plugins::LoadablePluginPlaceholder(render_frame,
                                          frame,
                                          params,
@@ -106,11 +104,12 @@ CefPluginPlaceholder* CefPluginPlaceholder::CreateBlockedPlugin(
   values.SetString("message", message);
   values.SetString("name", name);
   values.SetString("hide", l10n_util::GetStringUTF8(IDS_PLUGIN_HIDE));
-  values.SetString("pluginType",
-                   frame->View()->MainFrame()->IsWebLocalFrame() &&
-                   frame->View()->MainFrame()->GetDocument().IsPluginDocument()
-                       ? "document"
-                       : "embedded");
+  values.SetString(
+      "pluginType",
+      frame->View()->MainFrame()->IsWebLocalFrame() &&
+              frame->View()->MainFrame()->GetDocument().IsPluginDocument()
+          ? "document"
+          : "embedded");
 
   if (!power_saver_info.poster_attribute.empty()) {
     values.SetString("poster", power_saver_info.poster_attribute);
@@ -131,13 +130,13 @@ CefPluginPlaceholder* CefPluginPlaceholder::CreateBlockedPlugin(
   const base::StringPiece template_html(
       ResourceBundle::GetSharedInstance().GetRawDataResource(template_id));
 
-  DCHECK(!template_html.empty()) << "unable to load template. ID: "
-                                 << template_id;
+  DCHECK(!template_html.empty())
+      << "unable to load template. ID: " << template_id;
   std::string html_data = webui::GetI18nTemplateHtml(template_html, &values);
 
   // |blocked_plugin| will destroy itself when its WebViewPlugin is going away.
-  CefPluginPlaceholder* blocked_plugin = new CefPluginPlaceholder(
-      render_frame, frame, params, html_data, name);
+  CefPluginPlaceholder* blocked_plugin =
+      new CefPluginPlaceholder(render_frame, frame, params, html_data, name);
 
   if (!power_saver_info.poster_attribute.empty())
     blocked_plugin->BlockForPowerSaverPoster();
@@ -183,8 +182,8 @@ void CefPluginPlaceholder::PluginListChanged() {
   std::string mime_type(GetPluginParams().mime_type.Utf8());
   render_frame()->Send(new CefViewHostMsg_GetPluginInfo(
       routing_id(), GURL(GetPluginParams().url),
-      GetFrame()->Parent() == nullptr,
-      GetFrame()->Top()->GetSecurityOrigin(), mime_type, &output));
+      GetFrame()->Parent() == nullptr, GetFrame()->Top()->GetSecurityOrigin(),
+      mime_type, &output));
   if (output.status == status_)
     return;
   blink::WebPlugin* new_plugin = CefContentRendererClient::CreatePlugin(
@@ -219,13 +218,11 @@ void CefPluginPlaceholder::OnMenuClosed(int request_id) {
   context_menu_request_id_ = 0;
 }
 
-v8::Local<v8::Value> CefPluginPlaceholder::GetV8Handle(
-    v8::Isolate* isolate) {
+v8::Local<v8::Value> CefPluginPlaceholder::GetV8Handle(v8::Isolate* isolate) {
   return gin::CreateHandle(isolate, this).ToV8();
 }
 
-void CefPluginPlaceholder::ShowContextMenu(
-    const blink::WebMouseEvent& event) {
+void CefPluginPlaceholder::ShowContextMenu(const blink::WebMouseEvent& event) {
   if (context_menu_request_id_)
     return;  // Don't allow nested context menu requests.
 
@@ -279,8 +276,8 @@ blink::WebPlugin* CefPluginPlaceholder::CreatePlugin() {
         content::RenderFrame::DONT_RECORD_DECISION);
     // PluginPreroller manages its own lifetime.
     new CefPluginPreroller(
-        render_frame(), GetFrame(), GetPluginParams(),
-        GetPluginInfo(), GetIdentifier(), title_,
+        render_frame(), GetFrame(), GetPluginParams(), GetPluginInfo(),
+        GetIdentifier(), title_,
         l10n_util::GetStringFUTF16(IDS_PLUGIN_BLOCKED, title_),
         throttler.get());
   }

libcef/renderer/plugins/cef_plugin_placeholder.h

@@ -15,11 +15,10 @@
 
 enum class CefViewHostMsg_GetPluginInfo_Status;
 
-class CefPluginPlaceholder final
-    : public plugins::LoadablePluginPlaceholder,
-      public content::RenderThreadObserver,
-      public content::ContextMenuClient,
-      public gin::Wrappable<CefPluginPlaceholder> {
+class CefPluginPlaceholder final : public plugins::LoadablePluginPlaceholder,
+                                   public content::RenderThreadObserver,
+                                   public content::ContextMenuClient,
+                                   public gin::Wrappable<CefPluginPlaceholder> {
  public:
   static gin::WrapperInfo kWrapperInfo;
 

libcef/renderer/plugins/plugin_preroller.cc

@@ -67,10 +67,9 @@ void CefPluginPreroller::OnThrottleStateChange() {
   power_saver_info.poster_attribute = keyframe_data_url_.spec();
   power_saver_info.custom_poster_size = throttler_->GetSize();
 
-  CefPluginPlaceholder* placeholder =
-      CefPluginPlaceholder::CreateBlockedPlugin(
-          render_frame(), frame_, params_, info_, identifier_, name_,
-          IDR_PLUGIN_POSTER_HTML, message_, power_saver_info);
+  CefPluginPlaceholder* placeholder = CefPluginPlaceholder::CreateBlockedPlugin(
+      render_frame(), frame_, params_, info_, identifier_, name_,
+      IDR_PLUGIN_POSTER_HTML, message_, power_saver_info);
   placeholder->SetPremadePlugin(throttler_);
   placeholder->set_power_saver_enabled(true);
   placeholder->AllowLoading();

libcef/renderer/render_frame_observer.cc

@@ -2,7 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be found
 // in the LICENSE file.
 
-
 #include "base/compiler_specific.h"
 
 MSVC_PUSH_WARNING_LEVEL(0);
@@ -12,7 +11,7 @@ MSVC_POP_WARNING();
 // Enable deprecation warnings for MSVC. See http://crbug.com/585142.
 #if defined(OS_WIN)
 #pragma warning(push)
-#pragma warning(default:4996)
+#pragma warning(default : 4996)
 #endif
 
 #include "libcef/renderer/render_frame_observer.h"
@@ -22,16 +21,14 @@ MSVC_POP_WARNING();
 #include "libcef/renderer/v8_impl.h"
 
 #include "content/public/renderer/render_frame.h"
-#include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebKit.h"
+#include "third_party/WebKit/public/web/WebLocalFrame.h"
 
 CefRenderFrameObserver::CefRenderFrameObserver(
     content::RenderFrame* render_frame)
-    : content::RenderFrameObserver(render_frame) {
-}
+    : content::RenderFrameObserver(render_frame) {}
 
-CefRenderFrameObserver::~CefRenderFrameObserver() {
-}
+CefRenderFrameObserver::~CefRenderFrameObserver() {}
 
 void CefRenderFrameObserver::DidCreateScriptContext(
     v8::Handle<v8::Context> context,
@@ -102,7 +99,6 @@ void CefRenderFrameObserver::OnDestruct() {
   delete this;
 }
 
-
 // Enable deprecation warnings for MSVC. See http://crbug.com/585142.
 #if defined(OS_WIN)
 #pragma warning(pop)

libcef/renderer/render_message_filter.cc

@@ -4,8 +4,9 @@
 // found in the LICENSE file.
 
 #include "libcef/renderer/render_message_filter.h"
-#include "libcef/renderer/thread_util.h"
+
 #include "libcef/common/cef_messages.h"
+#include "libcef/renderer/thread_util.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
@@ -20,12 +21,9 @@
 
 using content::BrowserThread;
 
-CefRenderMessageFilter::CefRenderMessageFilter()
-    : channel_(NULL) {
-}
+CefRenderMessageFilter::CefRenderMessageFilter() : channel_(NULL) {}
 
-CefRenderMessageFilter::~CefRenderMessageFilter() {
-}
+CefRenderMessageFilter::~CefRenderMessageFilter() {}
 
 void CefRenderMessageFilter::OnFilterAdded(IPC::Channel* channel) {
   channel_ = channel;
@@ -68,8 +66,7 @@ bool CefRenderMessageFilter::Send(IPC::Message* message) {
 
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
-        BrowserThread::IO,
-        FROM_HERE,
+        BrowserThread::IO, FROM_HERE,
         base::Bind(base::IgnoreResult(&CefRenderMessageFilter::Send), this,
                    message));
     return true;
@@ -82,16 +79,15 @@ bool CefRenderMessageFilter::Send(IPC::Message* message) {
   return false;
 }
 
-void CefRenderMessageFilter::OnDevToolsAgentAttach(
-    const std::string& host_id, int session_id) {
+void CefRenderMessageFilter::OnDevToolsAgentAttach(const std::string& host_id,
+                                                   int session_id) {
   CEF_POST_TASK_RT(
       base::Bind(&CefRenderMessageFilter::OnDevToolsAgentAttach_RT, this));
 }
 
 void CefRenderMessageFilter::OnDevToolsAgentDetach(int32_t routing_id) {
-  CEF_POST_TASK_RT(
-      base::Bind(&CefRenderMessageFilter::OnDevToolsAgentDetach_RT, this,
-                 routing_id));
+  CEF_POST_TASK_RT(base::Bind(&CefRenderMessageFilter::OnDevToolsAgentDetach_RT,
+                              this, routing_id));
 }
 
 void CefRenderMessageFilter::OnIsCrashReportingEnabled(bool* enabled) {
@@ -117,10 +113,10 @@ void CefRenderMessageFilter::OnDevToolsAgentDetach_RT(int32_t routing_id) {
     // Try again in a bit.
     CEF_POST_DELAYED_TASK_RT(
         base::Bind(&CefRenderMessageFilter::OnDevToolsAgentDetach_RT, this,
-                   routing_id), 50);
+                   routing_id),
+        50);
     return;
   }
 
   CefContentRendererClient::Get()->DevToolsAgentDetached();
 }
-

libcef/renderer/render_message_filter.h

@@ -40,5 +40,4 @@ class CefRenderMessageFilter : public IPC::MessageFilter {
   DISALLOW_COPY_AND_ASSIGN(CefRenderMessageFilter);
 };
 
-
 #endif  // CEF_LIBCEF_RENDERER_RENDER_MESSAGE_FILTER_H_

libcef/renderer/render_thread_observer.cc

@@ -4,6 +4,7 @@
 // found in the LICENSE file.
 
 #include "libcef/renderer/render_thread_observer.h"
+
 #include "libcef/common/cef_messages.h"
 #include "libcef/common/net/net_resource_provider.h"
 #include "libcef/renderer/content_renderer_client.h"
@@ -19,7 +20,7 @@
 bool CefRenderThreadObserver::is_incognito_process_ = false;
 
 CefRenderThreadObserver::CefRenderThreadObserver()
-  : visited_link_slave_(new visitedlink::VisitedLinkSlave) {
+    : visited_link_slave_(new visitedlink::VisitedLinkSlave) {
   net::NetModule::SetResourceProvider(NetResourceProvider);
 
   content::RenderThread* thread = content::RenderThread::Get();
@@ -27,8 +28,7 @@ CefRenderThreadObserver::CefRenderThreadObserver()
       visited_link_slave_->GetBindCallback());
 }
 
-CefRenderThreadObserver::~CefRenderThreadObserver() {
-}
+CefRenderThreadObserver::~CefRenderThreadObserver() {}
 
 bool CefRenderThreadObserver::OnControlMessageReceived(
     const IPC::Message& message) {
@@ -61,14 +61,12 @@ void CefRenderThreadObserver::OnModifyCrossOriginWhitelistEntry(
   GURL gurl = GURL(params.source_origin);
   if (add) {
     blink::WebSecurityPolicy::AddOriginAccessWhitelistEntry(
-        gurl,
-        blink::WebString::FromUTF8(params.target_protocol),
+        gurl, blink::WebString::FromUTF8(params.target_protocol),
         blink::WebString::FromUTF8(params.target_domain),
         params.allow_target_subdomains);
   } else {
     blink::WebSecurityPolicy::RemoveOriginAccessWhitelistEntry(
-        gurl,
-        blink::WebString::FromUTF8(params.target_protocol),
+        gurl, blink::WebString::FromUTF8(params.target_protocol),
         blink::WebString::FromUTF8(params.target_domain),
         params.allow_target_subdomains);
   }

libcef/renderer/render_urlrequest_impl.cc

@@ -27,7 +27,6 @@ using blink::WebURLLoader;
 using blink::WebURLRequest;
 using blink::WebURLResponse;
 
-
 namespace {
 
 class CefWebURLLoaderClient : public blink::WebURLLoaderClient {
@@ -37,20 +36,14 @@ class CefWebURLLoaderClient : public blink::WebURLLoaderClient {
   ~CefWebURLLoaderClient() override;
 
   // blink::WebURLLoaderClient methods.
-  bool WillFollowRedirect(
-      WebURLRequest& newRequest,
-      const WebURLResponse& redirectResponse) override;
-  void DidSendData(
-      unsigned long long bytesSent,
-      unsigned long long totalBytesToBeSent) override;
-  void DidReceiveResponse(
-      const WebURLResponse& response) override;
-  void DidDownloadData(int dataLength,
-                       int encodedDataLength) override;
-  void DidReceiveData(const char* data,
-                      int dataLength) override;
-  void DidReceiveCachedMetadata(const char* data,
-                                int dataLength) override;
+  bool WillFollowRedirect(WebURLRequest& newRequest,
+                          const WebURLResponse& redirectResponse) override;
+  void DidSendData(unsigned long long bytesSent,
+                   unsigned long long totalBytesToBeSent) override;
+  void DidReceiveResponse(const WebURLResponse& response) override;
+  void DidDownloadData(int dataLength, int encodedDataLength) override;
+  void DidReceiveData(const char* data, int dataLength) override;
+  void DidReceiveCachedMetadata(const char* data, int dataLength) override;
   void DidFinishLoading(double finishTime,
                         int64_t totalEncodedDataLength,
                         int64_t totalEncodedBodyLength) override;
@@ -66,7 +59,6 @@ class CefWebURLLoaderClient : public blink::WebURLLoaderClient {
 
 }  // namespace
 
-
 // CefRenderURLRequest::Context -----------------------------------------------
 
 class CefRenderURLRequest::Context
@@ -75,16 +67,16 @@ class CefRenderURLRequest::Context
   Context(CefRefPtr<CefRenderURLRequest> url_request,
           CefRefPtr<CefRequest> request,
           CefRefPtr<CefURLRequestClient> client)
-    : url_request_(url_request),
-      request_(request),
-      client_(client),
-      task_runner_(base::MessageLoop::current()->task_runner()),
-      status_(UR_IO_PENDING),
-      error_code_(ERR_NONE),
-      upload_data_size_(0),
-      got_upload_progress_complete_(false),
-      download_data_received_(0),
-      download_data_total_(-1) {
+      : url_request_(url_request),
+        request_(request),
+        client_(client),
+        task_runner_(base::MessageLoop::current()->task_runner()),
+        status_(UR_IO_PENDING),
+        error_code_(ERR_NONE),
+        upload_data_size_(0),
+        got_upload_progress_complete_(false),
+        download_data_received_(0),
+        download_data_total_(-1) {
     // Mark the request as read-only.
     static_cast<CefRequestImpl*>(request_.get())->SetReadOnly(true);
   }
@@ -104,8 +96,8 @@ class CefRenderURLRequest::Context
     url_client_.reset(new CefWebURLLoaderClient(this, request_->GetFlags()));
 
     WebURLRequest urlRequest;
-    static_cast<CefRequestImpl*>(request_.get())->Get(urlRequest,
-                                                      upload_data_size_);
+    static_cast<CefRequestImpl*>(request_.get())
+        ->Get(urlRequest, upload_data_size_);
 
     loader_->LoadAsynchronously(urlRequest, url_client_.get());
     return true;
@@ -174,7 +166,7 @@ class CefRenderURLRequest::Context
 
     download_data_received_ += current;
     client_->OnDownloadProgress(url_request_.get(), download_data_received_,
-        download_data_total_);
+                                download_data_total_);
   }
 
   void OnDownloadData(const char* data, int dataLength) {
@@ -229,7 +221,6 @@ class CefRenderURLRequest::Context
   int64_t download_data_total_;
 };
 
-
 // CefWebURLLoaderClient --------------------------------------------------
 
 namespace {
@@ -237,12 +228,9 @@ namespace {
 CefWebURLLoaderClient::CefWebURLLoaderClient(
     CefRenderURLRequest::Context* context,
     int request_flags)
-  : context_(context),
-    request_flags_(request_flags) {
-}
+    : context_(context), request_flags_(request_flags) {}
 
-CefWebURLLoaderClient::~CefWebURLLoaderClient() {
-}
+CefWebURLLoaderClient::~CefWebURLLoaderClient() {}
 
 bool CefWebURLLoaderClient::WillFollowRedirect(
     WebURLRequest& newRequest,
@@ -250,24 +238,20 @@ bool CefWebURLLoaderClient::WillFollowRedirect(
   return true;
 }
 
-void CefWebURLLoaderClient::DidSendData(
-    unsigned long long bytesSent,
-    unsigned long long totalBytesToBeSent) {
+void CefWebURLLoaderClient::DidSendData(unsigned long long bytesSent,
+                                        unsigned long long totalBytesToBeSent) {
   if (request_flags_ & UR_FLAG_REPORT_UPLOAD_PROGRESS)
     context_->OnUploadProgress(bytesSent, totalBytesToBeSent);
 }
 
-void CefWebURLLoaderClient::DidReceiveResponse(
-    const WebURLResponse& response) {
+void CefWebURLLoaderClient::DidReceiveResponse(const WebURLResponse& response) {
   context_->OnResponse(response);
 }
 
 void CefWebURLLoaderClient::DidDownloadData(int dataLength,
-                                            int encodedDataLength) {
-}
+                                            int encodedDataLength) {}
 
-void CefWebURLLoaderClient::DidReceiveData(const char* data,
-                                           int dataLength) {
+void CefWebURLLoaderClient::DidReceiveData(const char* data, int dataLength) {
   context_->OnDownloadProgress(dataLength);
 
   if (!(request_flags_ & UR_FLAG_NO_DOWNLOAD_DATA))
@@ -275,8 +259,7 @@ void CefWebURLLoaderClient::DidReceiveData(const char* data,
 }
 
 void CefWebURLLoaderClient::DidReceiveCachedMetadata(const char* data,
-                                                     int dataLength) {
-}
+                                                     int dataLength) {}
 
 void CefWebURLLoaderClient::DidFinishLoading(double finishTime,
                                              int64_t totalEncodedDataLength,
@@ -290,10 +273,8 @@ void CefWebURLLoaderClient::DidFail(const WebURLError& error,
   context_->OnError(error);
 }
 
-
 }  // namespace
 
-
 // CefRenderURLRequest --------------------------------------------------------
 
 CefRenderURLRequest::CefRenderURLRequest(
@@ -302,8 +283,7 @@ CefRenderURLRequest::CefRenderURLRequest(
   context_ = new Context(this, request, client);
 }
 
-CefRenderURLRequest::~CefRenderURLRequest() {
-}
+CefRenderURLRequest::~CefRenderURLRequest() {}
 
 bool CefRenderURLRequest::Start() {
   if (!VerifyContext())

libcef/renderer/render_urlrequest_impl.h

@@ -6,6 +6,7 @@
 #define CEF_LIBCEF_RENDERER_RENDER_URLREQUEST_IMPL_H_
 
 #include "include/cef_urlrequest.h"
+
 #include "base/memory/ref_counted.h"
 
 class CefRenderURLRequest : public CefURLRequest {

libcef/renderer/thread_util.h

@@ -16,31 +16,30 @@
 
 #define CEF_REQUIRE_RT() DCHECK(CEF_CURRENTLY_ON_RT())
 
-#define CEF_REQUIRE_RT_RETURN(var) \
-  if (!CEF_CURRENTLY_ON_RT()) { \
+#define CEF_REQUIRE_RT_RETURN(var)              \
+  if (!CEF_CURRENTLY_ON_RT()) {                 \
     NOTREACHED() << "called on invalid thread"; \
-    return var; \
+    return var;                                 \
   }
 
-#define CEF_REQUIRE_RT_RETURN_VOID() \
-  if (!CEF_CURRENTLY_ON_RT()) { \
+#define CEF_REQUIRE_RT_RETURN_VOID()            \
+  if (!CEF_CURRENTLY_ON_RT()) {                 \
     NOTREACHED() << "called on invalid thread"; \
-    return; \
+    return;                                     \
   }
 
 #define CEF_RENDER_LOOP() \
-    (CefContentRendererClient::Get()->render_task_runner())
+  (CefContentRendererClient::Get()->render_task_runner())
 
-#define CEF_POST_TASK_RT(task) \
-    CEF_RENDER_LOOP()->PostTask(FROM_HERE, task)
+#define CEF_POST_TASK_RT(task) CEF_RENDER_LOOP()->PostTask(FROM_HERE, task)
 #define CEF_POST_DELAYED_TASK_RT(task, delay_ms) \
-    CEF_RENDER_LOOP()->PostDelayedTask(FROM_HERE, task, \
-        base::TimeDelta::FromMilliseconds(delay_ms))
+  CEF_RENDER_LOOP()->PostDelayedTask(            \
+      FROM_HERE, task, base::TimeDelta::FromMilliseconds(delay_ms))
 
 // Use this template in conjuction with RefCountedThreadSafe when you want to
 // ensure that an object is deleted on the render thread.
 struct CefDeleteOnRenderThread {
-  template<typename T>
+  template <typename T>
   static void Destruct(const T* x) {
     if (CEF_CURRENTLY_ON_RT()) {
       delete x;

libcef/renderer/v8_impl.cc

@@ -15,7 +15,7 @@
 // Enable deprecation warnings for MSVC. See http://crbug.com/585142.
 #if defined(OS_WIN)
 #pragma warning(push)
-#pragma warning(default:4996)
+#pragma warning(default : 4996)
 #endif
 
 #include "libcef/renderer/v8_impl.h"
@@ -32,8 +32,8 @@
 #include "base/lazy_instance.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_local.h"
-#include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
+#include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "url/gurl.h"
 
@@ -53,10 +53,10 @@ void SetPrivate(v8::Local<v8::Context> context,
                 const char* key,
                 v8::Local<v8::Value> value) {
   v8::Isolate* isolate = context->GetIsolate();
-  obj->SetPrivate(context,
-                  v8::Private::ForApi(isolate,
-                                      v8::String::NewFromUtf8(isolate, key)),
-                  value)
+  obj->SetPrivate(
+         context,
+         v8::Private::ForApi(isolate, v8::String::NewFromUtf8(isolate, key)),
+         value)
       .FromJust();
 }
 
@@ -65,10 +65,9 @@ bool GetPrivate(v8::Local<v8::Context> context,
                 const char* key,
                 v8::Local<v8::Value>* result) {
   v8::Isolate* isolate = context->GetIsolate();
-  return obj->GetPrivate(context,
-                         v8::Private::ForApi(
-                             isolate,
-                             v8::String::NewFromUtf8(isolate, key)))
+  return obj
+      ->GetPrivate(context, v8::Private::ForApi(
+                                isolate, v8::String::NewFromUtf8(isolate, key)))
       .ToLocal(result);
 }
 
@@ -142,8 +141,8 @@ class CefV8IsolateManager {
       message_listener_registered_ = true;
     }
 
-    isolate_->SetCaptureStackTraceForUncaughtExceptions(true,
-        stack_size, v8::StackTrace::kDetailed);
+    isolate_->SetCaptureStackTraceForUncaughtExceptions(
+        true, stack_size, v8::StackTrace::kDetailed);
   }
 
   void SetWorkerAttributes(int worker_id, const GURL& worker_url) {
@@ -156,19 +155,15 @@ class CefV8IsolateManager {
     return task_runner_;
   }
 
-  int worker_id() const {
-    return worker_id_;
-  }
+  int worker_id() const { return worker_id_; }
 
-  const GURL& worker_url() const {
-    return worker_url_;
-  }
+  const GURL& worker_url() const { return worker_url_; }
 
  private:
   v8::Isolate* isolate_;
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
-  typedef std::map<int, scoped_refptr<CefV8ContextState> > ContextMap;
+  typedef std::map<int, scoped_refptr<CefV8ContextState>> ContextMap;
   ContextMap context_map_;
 
   // Used for globally tracked objects that are not associated with a particular
@@ -189,9 +184,8 @@ class CefV8IsolateManager {
 // be re-worked (perhaps using a map keyed on v8::Isolate::GetCurrent()) if
 // in the future Chromium begins using the same Isolate across multiple threads.
 class CefV8StateManager {
-public:
-  CefV8StateManager() {
-  }
+ public:
+  CefV8StateManager() {}
 
   void CreateIsolateManager() {
     DCHECK(!current_tls_.Get());
@@ -224,8 +218,7 @@ CefV8IsolateManager* GetIsolateManager() {
 class V8TrackObject : public CefTrackNode {
  public:
   explicit V8TrackObject(v8::Isolate* isolate)
-      : isolate_(isolate),
-        external_memory_(0) {
+      : isolate_(isolate), external_memory_(0) {
     DCHECK(isolate_);
     isolate_->AdjustAmountOfExternalAllocatedMemory(
         static_cast<int>(sizeof(V8TrackObject)));
@@ -235,9 +228,7 @@ class V8TrackObject : public CefTrackNode {
         -static_cast<int>(sizeof(V8TrackObject)) - external_memory_);
   }
 
-  inline int GetExternallyAllocatedMemory() {
-    return external_memory_;
-  }
+  inline int GetExternallyAllocatedMemory() { return external_memory_; }
 
   int AdjustExternallyAllocatedMemory(int change_in_bytes) {
     int new_value = external_memory_ + change_in_bytes;
@@ -258,37 +249,28 @@ class V8TrackObject : public CefTrackNode {
     accessor_ = accessor;
   }
 
-  inline CefRefPtr<CefV8Accessor> GetAccessor() {
-    return accessor_;
-  }
+  inline CefRefPtr<CefV8Accessor> GetAccessor() { return accessor_; }
 
   inline void SetInterceptor(CefRefPtr<CefV8Interceptor> interceptor) {
     interceptor_ = interceptor;
   }
 
-  inline CefRefPtr<CefV8Interceptor> GetInterceptor() {
-    return interceptor_;
-  }
+  inline CefRefPtr<CefV8Interceptor> GetInterceptor() { return interceptor_; }
 
   inline void SetHandler(CefRefPtr<CefV8Handler> handler) {
     handler_ = handler;
   }
 
-  inline CefRefPtr<CefV8Handler> GetHandler() {
-    return handler_;
-  }
+  inline CefRefPtr<CefV8Handler> GetHandler() { return handler_; }
 
   inline void SetUserData(CefRefPtr<CefBaseRefCounted> user_data) {
     user_data_ = user_data;
   }
 
-  inline CefRefPtr<CefBaseRefCounted> GetUserData() {
-    return user_data_;
-  }
+  inline CefRefPtr<CefBaseRefCounted> GetUserData() { return user_data_; }
 
   // Attach this track object to the specified V8 object.
-  void AttachTo(v8::Local<v8::Context> context,
-                v8::Local<v8::Object> object) {
+  void AttachTo(v8::Local<v8::Context> context, v8::Local<v8::Object> object) {
     SetPrivate(context, object, kCefTrackObject,
                v8::External::New(isolate_, this));
   }
@@ -321,7 +303,6 @@ class V8TrackString : public CefTrackNode {
   std::string string_;
 };
 
-
 // Object wrapped in a v8::External and passed as the Data argument to
 // v8::FunctionTemplate::New.
 class V8FunctionData {
@@ -339,21 +320,15 @@ class V8FunctionData {
     return static_cast<V8FunctionData*>(v8::External::Cast(*data)->Value());
   }
 
-  CefString function_name() const {
-    return function_name_;
-  }
+  CefString function_name() const { return function_name_; }
 
-  CefV8Handler* handler() const {
-    return handler_;
-  }
+  CefV8Handler* handler() const { return handler_; }
 
  private:
   V8FunctionData(v8::Isolate* isolate,
                  const CefString& function_name,
                  CefV8Handler* handler)
-      : isolate_(isolate),
-        function_name_(function_name),
-        handler_(handler) {
+      : isolate_(isolate), function_name_(function_name), handler_(handler) {
     DCHECK(isolate_);
     DCHECK(handler_);
   }
@@ -394,41 +369,34 @@ class V8FunctionData {
   v8::Persistent<v8::External> handle_;
 };
 
-
 // Convert a CefString to a V8::String.
-v8::Local<v8::String> GetV8String(v8::Isolate* isolate,
-                                  const CefString& str) {
+v8::Local<v8::String> GetV8String(v8::Isolate* isolate, const CefString& str) {
 #if defined(CEF_STRING_TYPE_UTF16)
   // Already a UTF16 string.
   return v8::String::NewFromTwoByte(
       isolate,
       reinterpret_cast<uint16_t*>(
           const_cast<CefString::char_type*>(str.c_str())),
-      v8::String::kNormalString,
-      str.length());
+      v8::String::kNormalString, str.length());
 #elif defined(CEF_STRING_TYPE_UTF8)
   // Already a UTF8 string.
-  return v8::String::NewFromUtf8(isolate,
-                                 const_cast<char*>(str.c_str()),
-                                 v8::String::kNormalString,
-                                 str.length());
+  return v8::String::NewFromUtf8(isolate, const_cast<char*>(str.c_str()),
+                                 v8::String::kNormalString, str.length());
 #else
   // Convert the string to UTF8.
   std::string tmpStr = str;
-  return v8::String::NewFromUtf8(isolate,
-                                 tmpStr.c_str(),
-                                 v8::String::kNormalString,
-                                 tmpStr.length());
+  return v8::String::NewFromUtf8(isolate, tmpStr.c_str(),
+                                 v8::String::kNormalString, tmpStr.length());
 #endif
 }
 
 #if defined(CEF_STRING_TYPE_UTF16)
 void v8impl_string_dtor(char16* str) {
-  delete [] str;
+  delete[] str;
 }
 #elif defined(CEF_STRING_TYPE_UTF8)
 void v8impl_string_dtor(char* str) {
-  delete [] str;
+  delete[] str;
 }
 #endif
 
@@ -449,7 +417,7 @@ void GetCefString(v8::Local<v8::String> str, CefString& out) {
   cef_string_t* retws = out.GetWritableStruct();
   cef_string_utf8_to_wide(buf, len, retws);
 
-  delete [] buf;
+  delete[] buf;
 #else  // !defined(CEF_STRING_TYPE_WIDE)
 #if defined(CEF_STRING_TYPE_UTF16)
   int len = str->Length();
@@ -494,9 +462,8 @@ void FunctionCallbackImpl(const v8::FunctionCallbackInfo<v8::Value>& info) {
   if (data->handler()->Execute(data->function_name(), object, params, retval,
                                exception)) {
     if (!exception.empty()) {
-      info.GetReturnValue().Set(
-          isolate->ThrowException(
-              v8::Exception::Error(GetV8String(isolate, exception))));
+      info.GetReturnValue().Set(isolate->ThrowException(
+          v8::Exception::Error(GetV8String(isolate, exception))));
       return;
     } else {
       CefV8ValueImpl* rv = static_cast<CefV8ValueImpl*>(retval.get());
@@ -532,16 +499,15 @@ void AccessorNameGetterCallbackImpl(
     GetCefString(v8::Local<v8::String>::Cast(property), name);
     if (accessorPtr->Get(name, object, retval, exception)) {
       if (!exception.empty()) {
-          info.GetReturnValue().Set(
-              isolate->ThrowException(
-                  v8::Exception::Error(GetV8String(isolate, exception))));
-          return;
+        info.GetReturnValue().Set(isolate->ThrowException(
+            v8::Exception::Error(GetV8String(isolate, exception))));
+        return;
       } else {
-          CefV8ValueImpl* rv = static_cast<CefV8ValueImpl*>(retval.get());
-          if (rv && rv->IsValid()) {
-            info.GetReturnValue().Set(rv->GetV8Value(true));
-            return;
-          }
+        CefV8ValueImpl* rv = static_cast<CefV8ValueImpl*>(retval.get());
+        if (rv && rv->IsValid()) {
+          info.GetReturnValue().Set(rv->GetV8Value(true));
+          return;
+        }
       }
     }
   }
@@ -593,7 +559,7 @@ int PropertyToIndex(uint32_t index) {
 // V8 Interceptor callbacks.
 // T == v8::Local<v8::String> for named property handlers and
 // T == uint32_t for indexed property handlers
-template<typename T>
+template <typename T>
 void InterceptorGetterCallbackImpl(
     T property,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
@@ -624,7 +590,7 @@ void InterceptorGetterCallbackImpl(
   }
 }
 
-template<typename T>
+template <typename T>
 void InterceptorSetterCallbackImpl(
     T property,
     v8::Local<v8::Value> value,
@@ -657,12 +623,11 @@ class ExtensionWrapper : public v8::Extension {
   ExtensionWrapper(const char* extension_name,
                    const char* javascript_code,
                    CefV8Handler* handler)
-    : v8::Extension(extension_name, javascript_code), handler_(handler) {
-  }
+      : v8::Extension(extension_name, javascript_code), handler_(handler) {}
 
   v8::Handle<v8::FunctionTemplate> GetNativeFunctionTemplate(
-    v8::Isolate* isolate,
-    v8::Handle<v8::String> name) override {
+      v8::Isolate* isolate,
+      v8::Handle<v8::String> name) override {
     if (!handler_)
       return v8::Local<v8::FunctionTemplate>();
 
@@ -672,8 +637,7 @@ class ExtensionWrapper : public v8::Extension {
     v8::Local<v8::External> function_data =
         V8FunctionData::Create(isolate, func_name, handler_);
 
-    return v8::FunctionTemplate::New(isolate,
-                                     FunctionCallbackImpl,
+    return v8::FunctionTemplate::New(isolate, FunctionCallbackImpl,
                                      function_data);
   }
 
@@ -685,11 +649,11 @@ class CefV8ExceptionImpl : public CefV8Exception {
  public:
   CefV8ExceptionImpl(v8::Local<v8::Context> context,
                      v8::Local<v8::Message> message)
-    : line_number_(0),
-      start_position_(0),
-      end_position_(0),
-      start_column_(0),
-      end_column_(0) {
+      : line_number_(0),
+        start_position_(0),
+        end_position_(0),
+        start_column_(0),
+        end_column_(0) {
     if (message.IsEmpty())
       return;
 
@@ -749,12 +713,11 @@ void MessageListenerCallbackImpl(v8::Handle<v8::Message> message,
       static_cast<CefV8ContextImpl*>(context.get())->GetV8Context(), message);
 
   handler->OnUncaughtException(context->GetBrowser(), context->GetFrame(),
-      context, exception, stackTrace);
+                               context, exception, stackTrace);
 }
 
 }  // namespace
 
-
 // Global functions.
 
 void CefV8IsolateCreated() {
@@ -797,55 +760,50 @@ bool CefRegisterExtension(const CefString& extension_name,
     isolate_manager->AddGlobalTrackObject(object);
   }
 
-  ExtensionWrapper* wrapper = new ExtensionWrapper(
-      name->GetString(),
-      code->GetString(),
-      handler.get());
+  ExtensionWrapper* wrapper =
+      new ExtensionWrapper(name->GetString(), code->GetString(), handler.get());
 
   content::RenderThread::Get()->RegisterExtension(wrapper);
   return true;
 }
 
-
 // Helper macros
 
 #define CEF_V8_HAS_ISOLATE() (!!GetIsolateManager())
-#define CEF_V8_REQUIRE_ISOLATE_RETURN(var) \
-  if (!CEF_V8_HAS_ISOLATE()) { \
+#define CEF_V8_REQUIRE_ISOLATE_RETURN(var)     \
+  if (!CEF_V8_HAS_ISOLATE()) {                 \
     NOTREACHED() << "V8 isolate is not valid"; \
-    return var; \
+    return var;                                \
   }
 
 #define CEF_V8_CURRENTLY_ON_MLT() \
-    (!handle_.get() || handle_->BelongsToCurrentThread())
-#define CEF_V8_REQUIRE_MLT_RETURN(var) \
-  CEF_V8_REQUIRE_ISOLATE_RETURN(var); \
-  if (!CEF_V8_CURRENTLY_ON_MLT()) { \
+  (!handle_.get() || handle_->BelongsToCurrentThread())
+#define CEF_V8_REQUIRE_MLT_RETURN(var)            \
+  CEF_V8_REQUIRE_ISOLATE_RETURN(var);             \
+  if (!CEF_V8_CURRENTLY_ON_MLT()) {               \
     NOTREACHED() << "called on incorrect thread"; \
-    return var; \
+    return var;                                   \
   }
 
 #define CEF_V8_HANDLE_IS_VALID() (handle_.get() && handle_->IsValid())
 #define CEF_V8_REQUIRE_VALID_HANDLE_RETURN(ret) \
-  CEF_V8_REQUIRE_MLT_RETURN(ret); \
-  if (!CEF_V8_HANDLE_IS_VALID()) { \
-    NOTREACHED() << "V8 handle is not valid"; \
-    return ret; \
+  CEF_V8_REQUIRE_MLT_RETURN(ret);               \
+  if (!CEF_V8_HANDLE_IS_VALID()) {              \
+    NOTREACHED() << "V8 handle is not valid";   \
+    return ret;                                 \
   }
 
-#define CEF_V8_IS_VALID() \
-  (CEF_V8_HAS_ISOLATE() && \
-   CEF_V8_CURRENTLY_ON_MLT() && \
+#define CEF_V8_IS_VALID()                               \
+  (CEF_V8_HAS_ISOLATE() && CEF_V8_CURRENTLY_ON_MLT() && \
    CEF_V8_HANDLE_IS_VALID())
 
-#define CEF_V8_REQUIRE_OBJECT_RETURN(ret) \
-  CEF_V8_REQUIRE_VALID_HANDLE_RETURN(ret); \
-  if (type_ != TYPE_OBJECT) { \
+#define CEF_V8_REQUIRE_OBJECT_RETURN(ret)        \
+  CEF_V8_REQUIRE_VALID_HANDLE_RETURN(ret);       \
+  if (type_ != TYPE_OBJECT) {                    \
     NOTREACHED() << "V8 value is not an object"; \
-    return ret; \
+    return ret;                                  \
   }
 
-
 // CefV8HandleBase
 
 CefV8HandleBase::~CefV8HandleBase() {
@@ -869,7 +827,6 @@ CefV8HandleBase::CefV8HandleBase(v8::Isolate* isolate,
   context_state_ = manager->GetContextState(context);
 }
 
-
 // CefV8Context
 
 // static
@@ -903,14 +860,11 @@ bool CefV8Context::InContext() {
   return isolate->InContext();
 }
 
-
 // CefV8ContextImpl
 
 CefV8ContextImpl::CefV8ContextImpl(v8::Isolate* isolate,
                                    v8::Local<v8::Context> context)
-  : handle_(new Handle(isolate, context, context)),
-    enter_count_(0) {
-}
+    : handle_(new Handle(isolate, context, context)), enter_count_(0) {}
 
 CefV8ContextImpl::~CefV8ContextImpl() {
   DLOG_ASSERT(0 == enter_count_);
@@ -1048,8 +1002,8 @@ bool CefV8ContextImpl::Eval(const CefString& code,
   try_catch.SetVerbose(true);
 
   v8::MaybeLocal<v8::Value> func_rv =
-      webkit_glue::ExecuteV8ScriptAndReturnValue(source, source_url, start_line,
-          context, isolate, try_catch,
+      webkit_glue::ExecuteV8ScriptAndReturnValue(
+          source, source_url, start_line, context, isolate, try_catch,
           blink::AccessControlStatus::kNotSharableCrossOrigin);
 
   if (try_catch.HasCaught()) {
@@ -1080,7 +1034,6 @@ blink::WebFrame* CefV8ContextImpl::GetWebFrame() {
   return blink::WebLocalFrame::FrameForContext(context);
 }
 
-
 // CefV8ValueImpl::Handle
 
 CefV8ValueImpl::Handle::Handle(v8::Isolate* isolate,
@@ -1091,8 +1044,7 @@ CefV8ValueImpl::Handle::Handle(v8::Isolate* isolate,
       handle_(isolate, v),
       tracker_(tracker),
       should_persist_(false),
-      is_set_weak_(false) {
-}
+      is_set_weak_(false) {}
 
 CefV8ValueImpl::Handle::~Handle() {
   DCHECK(BelongsToCurrentThread());
@@ -1121,8 +1073,8 @@ CefV8ValueImpl::Handle::~Handle() {
   }
 }
 
-CefV8ValueImpl::Handle::handleType
-CefV8ValueImpl::Handle::GetNewV8Handle(bool should_persist) {
+CefV8ValueImpl::Handle::handleType CefV8ValueImpl::Handle::GetNewV8Handle(
+    bool should_persist) {
   DCHECK(IsValid());
   if (should_persist && !should_persist_)
     should_persist_ = true;
@@ -1136,7 +1088,8 @@ CefV8ValueImpl::Handle::GetPersistentV8Handle() {
 
 void CefV8ValueImpl::Handle::SetWeakIfNecessary() {
   if (!BelongsToCurrentThread()) {
-    task_runner()->PostTask(FROM_HERE,
+    task_runner()->PostTask(
+        FROM_HERE,
         base::Bind(&CefV8ValueImpl::Handle::SetWeakIfNecessary, this));
     return;
   }
@@ -1187,7 +1140,6 @@ void CefV8ValueImpl::Handle::SecondWeakCallback(
   wrapper->Release();
 }
 
-
 // CefV8Value
 
 // static
@@ -1284,8 +1236,8 @@ CefRefPtr<CefV8Value> CefV8Value::CreateObject(
   if (interceptor.get()) {
     v8::Local<v8::ObjectTemplate> tmpl = v8::ObjectTemplate::New(isolate);
     tmpl->SetNamedPropertyHandler(
-      InterceptorGetterCallbackImpl<v8::Local<v8::String>>,
-      InterceptorSetterCallbackImpl<v8::Local<v8::String>>);
+        InterceptorGetterCallbackImpl<v8::Local<v8::String>>,
+        InterceptorSetterCallbackImpl<v8::Local<v8::String>>);
 
     tmpl->SetIndexedPropertyHandler(InterceptorGetterCallbackImpl<uint32_t>,
                                     InterceptorSetterCallbackImpl<uint32_t>);
@@ -1362,9 +1314,7 @@ CefRefPtr<CefV8Value> CefV8Value::CreateFunction(
 
   // Create a new V8 function template.
   v8::Local<v8::FunctionTemplate> tmpl =
-      v8::FunctionTemplate::New(isolate,
-                                FunctionCallbackImpl,
-                                function_data);
+      v8::FunctionTemplate::New(isolate, FunctionCallbackImpl, function_data);
 
   // Retrieve the function object and set the name.
   v8::Local<v8::Function> func = tmpl->GetFunction();
@@ -1390,22 +1340,17 @@ CefRefPtr<CefV8Value> CefV8Value::CreateFunction(
   return impl.get();
 }
 
-
 // CefV8ValueImpl
 
 CefV8ValueImpl::CefV8ValueImpl(v8::Isolate* isolate)
-    : isolate_(isolate),
-      type_(TYPE_INVALID),
-      rethrow_exceptions_(false) {
+    : isolate_(isolate), type_(TYPE_INVALID), rethrow_exceptions_(false) {
   DCHECK(isolate_);
 }
 
 CefV8ValueImpl::CefV8ValueImpl(v8::Isolate* isolate,
                                v8::Local<v8::Context> context,
                                v8::Local<v8::Value> value)
-    : isolate_(isolate),
-      type_(TYPE_INVALID),
-      rethrow_exceptions_(false) {
+    : isolate_(isolate), type_(TYPE_INVALID), rethrow_exceptions_(false) {
   DCHECK(isolate_);
   InitFromV8Value(context, value);
 }
@@ -1504,7 +1449,8 @@ void CefV8ValueImpl::InitString(CefString& value) {
   }
 }
 
-void CefV8ValueImpl::InitObject(v8::Local<v8::Value> value, CefTrackNode* tracker) {
+void CefV8ValueImpl::InitObject(v8::Local<v8::Value> value,
+                                CefTrackNode* tracker) {
   DCHECK_EQ(type_, TYPE_INVALID);
   type_ = TYPE_OBJECT;
   handle_ = new Handle(isolate_, v8::Local<v8::Context>(), value, tracker);
@@ -1542,7 +1488,7 @@ v8::Local<v8::Value> CefV8ValueImpl::GetV8Value(bool should_persist) {
 bool CefV8ValueImpl::IsValid() {
   if (!CEF_V8_HAS_ISOLATE() || type_ == TYPE_INVALID ||
       (type_ == TYPE_OBJECT &&
-      (!handle_->BelongsToCurrentThread() || !handle_->IsValid()))) {
+       (!handle_->BelongsToCurrentThread() || !handle_->IsValid()))) {
     return false;
   }
   return true;
@@ -1910,15 +1856,12 @@ bool CefV8ValueImpl::SetValue(const CefString& key,
     // will not. It might be better to split this functionality into separate
     // methods.
     if (attribute == V8_PROPERTY_ATTRIBUTE_NONE) {
-      v8::Maybe<bool> set = obj->Set(context,
-                                     GetV8String(isolate, key),
-                                     impl->GetV8Value(true));
+      v8::Maybe<bool> set =
+          obj->Set(context, GetV8String(isolate, key), impl->GetV8Value(true));
       return (!HasCaught(context, try_catch) && set.FromJust());
     } else {
       v8::Maybe<bool> set = obj->DefineOwnProperty(
-          context,
-          GetV8String(isolate, key),
-          impl->GetV8Value(true),
+          context, GetV8String(isolate, key), impl->GetV8Value(true),
           static_cast<v8::PropertyAttribute>(attribute));
       return (!HasCaught(context, try_catch) && set.FromJust());
     }
@@ -1960,7 +1903,8 @@ bool CefV8ValueImpl::SetValue(int index, CefRefPtr<CefV8Value> value) {
   }
 }
 
-bool CefV8ValueImpl::SetValue(const CefString& key, AccessControl settings,
+bool CefV8ValueImpl::SetValue(const CefString& key,
+                              AccessControl settings,
                               PropertyAttribute attribute) {
   CEF_V8_REQUIRE_OBJECT_RETURN(false);
 
@@ -1988,15 +1932,16 @@ bool CefV8ValueImpl::SetValue(const CefString& key, AccessControl settings,
 
   v8::AccessorNameGetterCallback getter = AccessorNameGetterCallbackImpl;
   v8::AccessorNameSetterCallback setter =
-      (attribute & V8_PROPERTY_ATTRIBUTE_READONLY) ?
-          NULL : AccessorNameSetterCallbackImpl;
+      (attribute & V8_PROPERTY_ATTRIBUTE_READONLY)
+          ? NULL
+          : AccessorNameSetterCallbackImpl;
 
   v8::TryCatch try_catch(isolate);
   try_catch.SetVerbose(true);
-  v8::Maybe<bool> set = obj->SetAccessor(
-      context, GetV8String(isolate, key), getter, setter, obj,
-      static_cast<v8::AccessControl>(settings),
-      static_cast<v8::PropertyAttribute>(attribute));
+  v8::Maybe<bool> set =
+      obj->SetAccessor(context, GetV8String(isolate, key), getter, setter, obj,
+                       static_cast<v8::AccessControl>(settings),
+                       static_cast<v8::PropertyAttribute>(attribute));
   return (!HasCaught(context, try_catch) && set.FromJust());
 }
 
@@ -2168,17 +2113,17 @@ CefRefPtr<CefV8Handler> CefV8ValueImpl::GetFunctionHandler() {
 }
 
 CefRefPtr<CefV8Value> CefV8ValueImpl::ExecuteFunction(
-      CefRefPtr<CefV8Value> object,
-      const CefV8ValueList& arguments) {
+    CefRefPtr<CefV8Value> object,
+    const CefV8ValueList& arguments) {
   // An empty context value defaults to the current context.
   CefRefPtr<CefV8Context> context;
   return ExecuteFunctionWithContext(context, object, arguments);
 }
 
 CefRefPtr<CefV8Value> CefV8ValueImpl::ExecuteFunctionWithContext(
-      CefRefPtr<CefV8Context> context,
-      CefRefPtr<CefV8Value> object,
-      const CefV8ValueList& arguments)  {
+    CefRefPtr<CefV8Context> context,
+    CefRefPtr<CefV8Value> object,
+    const CefV8ValueList& arguments) {
   CEF_V8_REQUIRE_OBJECT_RETURN(NULL);
 
   v8::Isolate* isolate = handle_->isolate();
@@ -2231,7 +2176,7 @@ CefRefPtr<CefV8Value> CefV8ValueImpl::ExecuteFunctionWithContext(
     recv = context_local->Global();
   }
 
-  v8::Local<v8::Value> *argv = NULL;
+  v8::Local<v8::Value>* argv = NULL;
   if (argc > 0) {
     argv = new v8::Local<v8::Value>[argc];
     for (int i = 0; i < argc; ++i) {
@@ -2246,18 +2191,17 @@ CefRefPtr<CefV8Value> CefV8ValueImpl::ExecuteFunctionWithContext(
     v8::TryCatch try_catch(isolate);
     try_catch.SetVerbose(true);
 
-    v8::MaybeLocal<v8::Value> func_rv =
-        webkit_glue::CallV8Function(context_local, func, recv, argc, argv,
-                                    handle_->isolate());
+    v8::MaybeLocal<v8::Value> func_rv = webkit_glue::CallV8Function(
+        context_local, func, recv, argc, argv, handle_->isolate());
 
     if (!HasCaught(context_local, try_catch) && !func_rv.IsEmpty()) {
-      retval = new CefV8ValueImpl(isolate, context_local,
-                                  func_rv.ToLocalChecked());
+      retval =
+          new CefV8ValueImpl(isolate, context_local, func_rv.ToLocalChecked());
     }
   }
 
   if (argv)
-    delete [] argv;
+    delete[] argv;
 
   return retval;
 }
@@ -2276,7 +2220,6 @@ bool CefV8ValueImpl::HasCaught(v8::Local<v8::Context> context,
   }
 }
 
-
 // CefV8StackTrace
 
 // static
@@ -2285,21 +2228,18 @@ CefRefPtr<CefV8StackTrace> CefV8StackTrace::GetCurrent(int frame_limit) {
 
   v8::Isolate* isolate = GetIsolateManager()->isolate();
   v8::HandleScope handle_scope(isolate);
-  v8::Local<v8::StackTrace> stackTrace =
-        v8::StackTrace::CurrentStackTrace(
-            isolate, frame_limit, v8::StackTrace::kDetailed);
+  v8::Local<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(
+      isolate, frame_limit, v8::StackTrace::kDetailed);
   if (stackTrace.IsEmpty())
     return NULL;
   return new CefV8StackTraceImpl(isolate, stackTrace);
 }
 
-
 // CefV8StackTraceImpl
 
-CefV8StackTraceImpl::CefV8StackTraceImpl(
-    v8::Isolate* isolate,
-    v8::Local<v8::StackTrace> handle) {
-  if  (!handle.IsEmpty()) {
+CefV8StackTraceImpl::CefV8StackTraceImpl(v8::Isolate* isolate,
+                                         v8::Local<v8::StackTrace> handle) {
+  if (!handle.IsEmpty()) {
     int frame_count = handle->GetFrameCount();
     if (frame_count > 0) {
       frames_.reserve(frame_count);
@@ -2310,8 +2250,7 @@ CefV8StackTraceImpl::CefV8StackTraceImpl(
   }
 }
 
-CefV8StackTraceImpl::~CefV8StackTraceImpl() {
-}
+CefV8StackTraceImpl::~CefV8StackTraceImpl() {}
 
 bool CefV8StackTraceImpl::IsValid() {
   return true;
@@ -2327,16 +2266,11 @@ CefRefPtr<CefV8StackFrame> CefV8StackTraceImpl::GetFrame(int index) {
   return frames_[index];
 }
 
-
 // CefV8StackFrameImpl
 
-CefV8StackFrameImpl::CefV8StackFrameImpl(
-    v8::Isolate* isolate,
-    v8::Local<v8::StackFrame> handle)
-    : line_number_(0),
-      column_(0),
-      is_eval_(false),
-      is_constructor_(false) {
+CefV8StackFrameImpl::CefV8StackFrameImpl(v8::Isolate* isolate,
+                                         v8::Local<v8::StackFrame> handle)
+    : line_number_(0), column_(0), is_eval_(false), is_constructor_(false) {
   if (handle.IsEmpty())
     return;
   GetCefString(handle->GetScriptName(), script_name_);
@@ -2348,8 +2282,7 @@ CefV8StackFrameImpl::CefV8StackFrameImpl(
   is_constructor_ = handle->IsConstructor();
 }
 
-CefV8StackFrameImpl::~CefV8StackFrameImpl() {
-}
+CefV8StackFrameImpl::~CefV8StackFrameImpl() {}
 
 bool CefV8StackFrameImpl::IsValid() {
   return true;
@@ -2383,7 +2316,6 @@ bool CefV8StackFrameImpl::IsConstructor() {
   return is_constructor_;
 }
 
-
 // Enable deprecation warnings for MSVC. See http://crbug.com/585142.
 #if defined(OS_WIN)
 #pragma warning(pop)

libcef/renderer/v8_impl.h

@@ -11,11 +11,11 @@
 #include "include/cef_v8.h"
 #include "libcef/common/tracker.h"
 
-#include "v8/include/v8.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/sequenced_task_runner.h"
+#include "v8/include/v8.h"
 
 class CefTrackNode;
 class GURL;
@@ -70,11 +70,10 @@ class CefV8ContextState : public base::RefCounted<CefV8ContextState> {
   CefTrackManager track_manager_;
 };
 
-
 // Use this template in conjuction with RefCountedThreadSafe to ensure that a
 // V8 object is deleted on the correct thread.
 struct CefV8DeleteOnMessageLoopThread {
-  template<typename T>
+  template <typename T>
   static void Destruct(const T* x) {
     if (x->task_runner()->RunsTasksOnCurrentThread()) {
       delete x;
@@ -91,9 +90,9 @@ struct CefV8DeleteOnMessageLoopThread {
 };
 
 // Base class for V8 Handle types.
-class CefV8HandleBase :
-    public base::RefCountedThreadSafe<CefV8HandleBase,
-                                      CefV8DeleteOnMessageLoopThread> {
+class CefV8HandleBase
+    : public base::RefCountedThreadSafe<CefV8HandleBase,
+                                        CefV8DeleteOnMessageLoopThread> {
  public:
   // Returns true if there is no underlying context or if the underlying context
   // is valid.
@@ -116,8 +115,7 @@ class CefV8HandleBase :
 
   // |context| is the context that owns this handle. If empty the current
   // context will be used.
-  CefV8HandleBase(v8::Isolate* isolate,
-                  v8::Local<v8::Context> context);
+  CefV8HandleBase(v8::Isolate* isolate, v8::Local<v8::Context> context);
   virtual ~CefV8HandleBase();
 
  protected:
@@ -137,23 +135,17 @@ class CefV8Handle : public CefV8HandleBase {
   CefV8Handle(v8::Isolate* isolate,
               v8::Local<v8::Context> context,
               handleType v)
-      : CefV8HandleBase(isolate, context),
-        handle_(isolate, v) {
-  }
+      : CefV8HandleBase(isolate, context), handle_(isolate, v) {}
 
   handleType GetNewV8Handle() {
     DCHECK(IsValid());
     return handleType::New(isolate(), handle_);
   }
 
-  persistentType& GetPersistentV8Handle() {
-    return handle_;
-  }
+  persistentType& GetPersistentV8Handle() { return handle_; }
 
  protected:
-  ~CefV8Handle() override {
-    handle_.Reset();
-  }
+  ~CefV8Handle() override { handle_.Reset(); }
 
   persistentType handle_;
 
@@ -163,14 +155,11 @@ class CefV8Handle : public CefV8HandleBase {
 // Specialization for v8::Value with empty implementation to avoid incorrect
 // usage.
 template <>
-class CefV8Handle<v8::Value> {
-};
-
+class CefV8Handle<v8::Value> {};
 
 class CefV8ContextImpl : public CefV8Context {
  public:
-  CefV8ContextImpl(v8::Isolate* isolate,
-                   v8::Local<v8::Context> context);
+  CefV8ContextImpl(v8::Isolate* isolate, v8::Local<v8::Context> context);
   ~CefV8ContextImpl() override;
 
   CefRefPtr<CefTaskRunner> GetTaskRunner() override;
@@ -258,10 +247,12 @@ class CefV8ValueImpl : public CefV8Value {
   bool DeleteValue(int index) override;
   CefRefPtr<CefV8Value> GetValue(const CefString& key) override;
   CefRefPtr<CefV8Value> GetValue(int index) override;
-  bool SetValue(const CefString& key, CefRefPtr<CefV8Value> value,
+  bool SetValue(const CefString& key,
+                CefRefPtr<CefV8Value> value,
                 PropertyAttribute attribute) override;
   bool SetValue(int index, CefRefPtr<CefV8Value> value) override;
-  bool SetValue(const CefString& key, AccessControl settings,
+  bool SetValue(const CefString& key,
+                AccessControl settings,
                 PropertyAttribute attribute) override;
   bool GetKeys(std::vector<CefString>& keys) override;
   bool SetUserData(CefRefPtr<CefBaseRefCounted> user_data) override;
@@ -323,7 +314,7 @@ class CefV8ValueImpl : public CefV8Value {
   };
 
   v8::Isolate* isolate_;
- 
+
   enum {
     TYPE_INVALID = 0,
     TYPE_UNDEFINED,
@@ -358,8 +349,7 @@ class CefV8ValueImpl : public CefV8Value {
 
 class CefV8StackTraceImpl : public CefV8StackTrace {
  public:
-  CefV8StackTraceImpl(v8::Isolate* isolate,
-                      v8::Local<v8::StackTrace> handle);
+  CefV8StackTraceImpl(v8::Isolate* isolate, v8::Local<v8::StackTrace> handle);
   ~CefV8StackTraceImpl() override;
 
   bool IsValid() override;
@@ -367,7 +357,7 @@ class CefV8StackTraceImpl : public CefV8StackTrace {
   CefRefPtr<CefV8StackFrame> GetFrame(int index) override;
 
  private:
-  std::vector<CefRefPtr<CefV8StackFrame> > frames_;
+  std::vector<CefRefPtr<CefV8StackFrame>> frames_;
 
   IMPLEMENT_REFCOUNTING(CefV8StackTraceImpl);
   DISALLOW_COPY_AND_ASSIGN(CefV8StackTraceImpl);
@@ -375,8 +365,7 @@ class CefV8StackTraceImpl : public CefV8StackTrace {
 
 class CefV8StackFrameImpl : public CefV8StackFrame {
  public:
-  CefV8StackFrameImpl(v8::Isolate* isolate,
-                      v8::Local<v8::StackFrame> handle);
+  CefV8StackFrameImpl(v8::Isolate* isolate, v8::Local<v8::StackFrame> handle);
   ~CefV8StackFrameImpl() override;
 
   bool IsValid() override;

libcef/renderer/webkit_glue.cc

@@ -188,12 +188,14 @@ v8::MaybeLocal<v8::Value> ExecuteV8ScriptAndReturnValue(
   if (start_line < 1)
     start_line = 1;
 
-  const blink::KURL kurl = source_url.IsEmpty() ?
-      blink::KURL() : blink::KURL(blink::kParsedURLString, source_url);
+  const blink::KURL kurl =
+      source_url.IsEmpty() ? blink::KURL()
+                           : blink::KURL(blink::kParsedURLString, source_url);
 
-  const blink::ScriptSourceCode ssc = blink::ScriptSourceCode(source, kurl,
+  const blink::ScriptSourceCode ssc = blink::ScriptSourceCode(
+      source, kurl,
       WTF::TextPosition(WTF::OrdinalNumber::FromOneBasedInt(start_line),
-      WTF::OrdinalNumber::FromZeroBasedInt(0)));
+                        WTF::OrdinalNumber::FromZeroBasedInt(0)));
 
   v8::MaybeLocal<v8::Value> result;
 
@@ -206,13 +208,14 @@ v8::MaybeLocal<v8::Value> ExecuteV8ScriptAndReturnValue(
       v8CacheOptions = frame->GetSettings()->GetV8CacheOptions();
 
     v8::Local<v8::Script> script;
-    if (!blink::V8Call(blink::V8ScriptRunner::CompileScript(ssc, isolate,
-            accessControlStatus, v8CacheOptions), script, tryCatch)) {
+    if (!blink::V8Call(blink::V8ScriptRunner::CompileScript(
+                           ssc, isolate, accessControlStatus, v8CacheOptions),
+                       script, tryCatch)) {
       return result;
     }
 
-    result = blink::V8ScriptRunner::RunCompiledScript(isolate, script,
-        blink::ToExecutionContext(context));
+    result = blink::V8ScriptRunner::RunCompiledScript(
+        isolate, script, blink::ToExecutionContext(context));
   }
 
   return result;