Clang format slam.

net/http/url_security_manager_win.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/http/url_security_manager.h"
 
 #include <urlmon.h>
 #pragma comment(lib, "urlmon.lib")
 
 #include "base/strings/string_util.h"
@@ skipping 41 matching lines @@
     const GURL& auth_origin) const {
   if (!const_cast<URLSecurityManagerWin*>(this)->EnsureSystemSecurityManager())
     return false;
 
   std::wstring url_w = base::ASCIIToWide(auth_origin.spec());
   DWORD policy = 0;
   HRESULT hr;
   hr = security_manager_->ProcessUrlAction(url_w.c_str(),
                                            URLACTION_CREDENTIALS_USE,
                                            reinterpret_cast<BYTE*>(&policy),
-                                           sizeof(policy), NULL, 0,
-                                           PUAF_NOUI, 0);
+                                           sizeof(policy),
+                                           NULL,
+                                           0,
+                                           PUAF_NOUI,
+                                           0);
   if (FAILED(hr)) {
     LOG(ERROR) << "IInternetSecurityManager::ProcessUrlAction failed: " << hr;
     return false;
   }
 
   // Four possible policies for URLACTION_CREDENTIALS_USE.  See the MSDN page
   // "About URL Security Zones" at
   // http://msdn.microsoft.com/en-us/library/ms537183(VS.85).aspx
   switch (policy) {
     case URLPOLICY_CREDENTIALS_SILENT_LOGON_OK:
@@ skipping 31 matching lines @@
 bool URLSecurityManagerWin::CanDelegate(const GURL& auth_origin) const {
   // TODO(cbentzel): Could this just use the security zone as well? Apparently
   //                 this is what IE does as well.
   if (whitelist_delegate_.get())
     return whitelist_delegate_->IsValid(auth_origin, HttpAuth::AUTH_SERVER);
   return false;
 }
 
 bool URLSecurityManagerWin::EnsureSystemSecurityManager() {
   if (!security_manager_) {
-    HRESULT hr = CoInternetCreateSecurityManager(NULL,
-                                                 security_manager_.Receive(),
-                                                 NULL);
+    HRESULT hr = CoInternetCreateSecurityManager(
+        NULL, security_manager_.Receive(), NULL);
     if (FAILED(hr) || !security_manager_) {
       LOG(ERROR) << "Unable to create the Windows Security Manager instance";
       return false;
     }
   }
   return true;
 }
 
 // static
 URLSecurityManager* URLSecurityManager::Create(
     const HttpAuthFilter* whitelist_default,
     const HttpAuthFilter* whitelist_delegate) {
   // If we have a whitelist, just use that.
   if (whitelist_default)
     return new URLSecurityManagerWhitelist(whitelist_default,
                                            whitelist_delegate);
   return new URLSecurityManagerWin(whitelist_delegate);
 }
 
 }  //  namespace net