Clang format slam.

net/proxy/proxy_resolver_v8.cc

 // Copyright (c) 2012 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/proxy/proxy_resolver_v8.h"
 
 #include <algorithm>
 #include <cstdio>
 
 #include "base/basictypes.h"
@@ skipping 97 matching lines @@
 // External string wrapper so V8 can access a string literal.
 class V8ExternalASCIILiteral : public v8::String::ExternalAsciiStringResource {
  public:
   // |ascii| must be a NULL-terminated C string, and must remain valid
   // throughout this object's lifetime.
   V8ExternalASCIILiteral(const char* ascii, size_t length)
       : ascii_(ascii), length_(length) {
     DCHECK(IsStringASCII(ascii));
   }
 
-  virtual const char* data() const OVERRIDE {
-    return ascii_;
-  }
+  virtual const char* data() const OVERRIDE { return ascii_; }
 
-  virtual size_t length() const OVERRIDE {
-    return length_;
-  }
+  virtual size_t length() const OVERRIDE { return length_; }
 
  private:
   const char* ascii_;
   size_t length_;
   DISALLOW_COPY_AND_ASSIGN(V8ExternalASCIILiteral);
 };
 
 // When creating a v8::String from a C++ string we have two choices: create
 // a copy, or create a wrapper that shares the same underlying storage.
 // For small strings it is better to just make a copy, whereas for large
@@ skipping 18 matching lines @@
   // to wstring, and hence has character type wchar_t not uint16_t.
   if (len > 0)
     s->Write(reinterpret_cast<uint16_t*>(WriteInto(&result, len + 1)), 0, len);
   return result;
 }
 
 // Converts an ASCII std::string to a V8 string.
 v8::Local<v8::String> ASCIIStringToV8String(v8::Isolate* isolate,
                                             const std::string& s) {
   DCHECK(IsStringASCII(s));
-  return v8::String::NewFromUtf8(isolate, s.data(), v8::String::kNormalString,
-                                 s.size());
+  return v8::String::NewFromUtf8(
+      isolate, s.data(), v8::String::kNormalString, s.size());
 }
 
 // Converts a UTF16 base::string16 (warpped by a ProxyResolverScriptData) to a
 // V8 string.
 v8::Local<v8::String> ScriptDataToV8String(
-    v8::Isolate* isolate, const scoped_refptr<ProxyResolverScriptData>& s) {
+    v8::Isolate* isolate,
+    const scoped_refptr<ProxyResolverScriptData>& s) {
   if (s->utf16().size() * 2 <= kMaxStringBytesForCopy) {
     return v8::String::NewFromTwoByte(
         isolate,
         reinterpret_cast<const uint16_t*>(s->utf16().data()),
         v8::String::kNormalString,
         s->utf16().size());
   }
   return v8::String::NewExternal(isolate,
                                  new V8ExternalStringFromScriptData(s));
 }
 
 // Converts an ASCII string literal to a V8 string.
 v8::Local<v8::String> ASCIILiteralToV8String(v8::Isolate* isolate,
                                              const char* ascii) {
   DCHECK(IsStringASCII(ascii));
   size_t length = strlen(ascii);
   if (length <= kMaxStringBytesForCopy)
-    return v8::String::NewFromUtf8(isolate, ascii, v8::String::kNormalString,
-                                   length);
+    return v8::String::NewFromUtf8(
+        isolate, ascii, v8::String::kNormalString, length);
   return v8::String::NewExternal(isolate,
                                  new V8ExternalASCIILiteral(ascii, length));
 }
 
 // Stringizes a V8 object by calling its toString() method. Returns true
 // on success. This may fail if the toString() throws an exception.
 bool V8ObjectToUTF16String(v8::Handle<v8::Value> object,
                            base::string16* utf16_result,
                            v8::Isolate* isolate) {
   if (object.IsEmpty())
@@ skipping 19 matching lines @@
 
   // If the hostname is already in ASCII, simply return it as is.
   if (IsStringASCII(hostname_utf16)) {
     *hostname = base::UTF16ToASCII(hostname_utf16);
     return true;
   }
 
   // Otherwise try to convert it from IDN to punycode.
   const int kInitialBufferSize = 256;
   url::RawCanonOutputT<base::char16, kInitialBufferSize> punycode_output;
-  if (!url::IDNToASCII(hostname_utf16.data(), hostname_utf16.length(),
-                       &punycode_output)) {
+  if (!url::IDNToASCII(
+          hostname_utf16.data(), hostname_utf16.length(), &punycode_output)) {
     return false;
   }
 
   // |punycode_output| should now be ASCII; convert it to a std::string.
   // (We could use UTF16ToASCII() instead, but that requires an extra string
   // copy. Since ASCII is a subset of UTF8 the following is equivalent).
-  bool success = base::UTF16ToUTF8(punycode_output.data(),
-                             punycode_output.length(),
-                             hostname);
+  bool success = base::UTF16ToUTF8(
+      punycode_output.data(), punycode_output.length(), hostname);
   DCHECK(success);
   DCHECK(IsStringASCII(*hostname));
   return success;
 }
 
 // Wrapper for passing around IP address strings and IPAddressNumber objects.
 struct IPAddress {
   IPAddress(const std::string& ip_string, const IPAddressNumber& ip_number)
-      : string_value(ip_string),
-        ip_address_number(ip_number) {
-  }
+      : string_value(ip_string), ip_address_number(ip_number) {}
 
   // Used for sorting IP addresses in ascending order in SortIpAddressList().
   // IP6 addresses are placed ahead of IPv4 addresses.
   bool operator<(const IPAddress& rhs) const {
     const IPAddressNumber& ip1 = this->ip_address_number;
     const IPAddressNumber& ip2 = rhs.ip_address_number;
     if (ip1.size() != ip2.size())
       return ip1.size() > ip2.size();  // IPv6 before IPv4.
     DCHECK(ip1.size() == ip2.size());
     return memcmp(&ip1[0], &ip2[0], ip1.size()) < 0;  // Ascending order.
@@ skipping 76 matching lines @@
   return IPNumberMatchesPrefix(address, prefix, prefix_length_in_bits);
 }
 
 }  // namespace
 
 // ProxyResolverV8::Context ---------------------------------------------------
 
 class ProxyResolverV8::Context {
  public:
   Context(ProxyResolverV8* parent, v8::Isolate* isolate)
-      : parent_(parent),
-        isolate_(isolate) {
+      : parent_(parent), isolate_(isolate) {
     DCHECK(isolate);
   }
 
   ~Context() {
     v8::Locker locked(isolate_);
     v8::Isolate::Scope isolate_scope(isolate_);
 
     v8_this_.Reset();
     v8_context_.Reset();
   }
 
-  JSBindings* js_bindings() {
-    return parent_->js_bindings_;
-  }
+  JSBindings* js_bindings() { return parent_->js_bindings_; }
 
   int ResolveProxy(const GURL& query_url, ProxyInfo* results) {
     v8::Locker locked(isolate_);
     v8::Isolate::Scope isolate_scope(isolate_);
     v8::HandleScope scope(isolate_);
 
     v8::Local<v8::Context> context =
         v8::Local<v8::Context>::New(isolate_, v8_context_);
     v8::Context::Scope function_scope(context);
 
     v8::Local<v8::Value> function;
     if (!GetFindProxyForURL(&function)) {
       js_bindings()->OnError(
           -1, base::ASCIIToUTF16("FindProxyForURL() is undefined."));
       return ERR_PAC_SCRIPT_FAILED;
     }
 
     v8::Handle<v8::Value> argv[] = {
-      ASCIIStringToV8String(isolate_, query_url.spec()),
-      ASCIIStringToV8String(isolate_, query_url.HostNoBrackets()),
+        ASCIIStringToV8String(isolate_, query_url.spec()),
+        ASCIIStringToV8String(isolate_, query_url.HostNoBrackets()),
     };
 
     v8::TryCatch try_catch;
     v8::Local<v8::Value> ret = v8::Function::Cast(*function)->Call(
         context->Global(), arraysize(argv), argv);
 
     if (try_catch.HasCaught()) {
       HandleError(try_catch.Message());
       return ERR_PAC_SCRIPT_FAILED;
     }
 
     if (!ret->IsString()) {
       js_bindings()->OnError(
           -1, base::ASCIIToUTF16("FindProxyForURL() did not return a string."));
       return ERR_PAC_SCRIPT_FAILED;
     }
 
     base::string16 ret_str = V8StringToUTF16(ret->ToString());
 
     if (!IsStringASCII(ret_str)) {
       // TODO(eroman): Rather than failing when a wide string is returned, we
       //               could extend the parsing to handle IDNA hostnames by
       //               converting them to ASCII punycode.
       //               crbug.com/47234
       base::string16 error_message =
-          base::ASCIIToUTF16("FindProxyForURL() returned a non-ASCII string "
-                             "(crbug.com/47234): ") + ret_str;
+          base::ASCIIToUTF16(
+              "FindProxyForURL() returned a non-ASCII string "
+              "(crbug.com/47234): ") +
+          ret_str;
       js_bindings()->OnError(-1, error_message);
       return ERR_PAC_SCRIPT_FAILED;
     }
 
     results->UsePacString(base::UTF16ToASCII(ret_str));
     return OK;
   }
 
   int InitV8(const scoped_refptr<ProxyResolverScriptData>& pac_script) {
     v8::Locker locked(isolate_);
@@ skipping 28 matching lines @@
         v8::FunctionTemplate::New(isolate_, &DnsResolveExCallback, v8_this);
     global_template->Set(ASCIILiteralToV8String(isolate_, "dnsResolveEx"),
                          dns_resolve_ex_template);
 
     v8::Local<v8::FunctionTemplate> my_ip_address_ex_template =
         v8::FunctionTemplate::New(isolate_, &MyIpAddressExCallback, v8_this);
     global_template->Set(ASCIILiteralToV8String(isolate_, "myIpAddressEx"),
                          my_ip_address_ex_template);
 
     v8::Local<v8::FunctionTemplate> sort_ip_address_list_template =
-        v8::FunctionTemplate::New(isolate_,
-                                  &SortIpAddressListCallback,
-                                  v8_this);
+        v8::FunctionTemplate::New(
+            isolate_, &SortIpAddressListCallback, v8_this);
     global_template->Set(ASCIILiteralToV8String(isolate_, "sortIpAddressList"),
                          sort_ip_address_list_template);
 
     v8::Local<v8::FunctionTemplate> is_in_net_ex_template =
         v8::FunctionTemplate::New(isolate_, &IsInNetExCallback, v8_this);
     global_template->Set(ASCIILiteralToV8String(isolate_, "isInNetEx"),
                          is_in_net_ex_template);
 
-    v8_context_.Reset(
-        isolate_, v8::Context::New(isolate_, NULL, global_template));
+    v8_context_.Reset(isolate_,
+                      v8::Context::New(isolate_, NULL, global_template));
 
     v8::Local<v8::Context> context =
         v8::Local<v8::Context>::New(isolate_, v8_context_);
     v8::Context::Scope ctx(context);
 
     // Add the PAC utility functions to the environment.
     // (This script should never fail, as it is a string literal!)
     // Note that the two string literals are concatenated.
-    int rv = RunScript(
-        ASCIILiteralToV8String(
-            isolate_,
-            PROXY_RESOLVER_SCRIPT
-            PROXY_RESOLVER_SCRIPT_EX),
-        kPacUtilityResourceName);
+    int rv =
+        RunScript(ASCIILiteralToV8String(
+                      isolate_, PROXY_RESOLVER_SCRIPT PROXY_RESOLVER_SCRIPT_EX),
+                  kPacUtilityResourceName);
     if (rv != OK) {
       NOTREACHED();
       return rv;
     }
 
     // Add the user's PAC code to the environment.
     rv =
         RunScript(ScriptDataToV8String(isolate_, pac_script), kPacResourceName);
     if (rv != OK)
       return rv;
 
     // At a minimum, the FindProxyForURL() function must be defined for this
     // to be a legitimiate PAC script.
     v8::Local<v8::Value> function;
     if (!GetFindProxyForURL(&function)) {
       js_bindings()->OnError(
           -1, base::ASCIIToUTF16("FindProxyForURL() is undefined."));
       return ERR_PAC_SCRIPT_FAILED;
     }
 
     return OK;
   }
 
  private:
   bool GetFindProxyForURL(v8::Local<v8::Value>* function) {
     v8::Local<v8::Context> context =
         v8::Local<v8::Context>::New(isolate_, v8_context_);
-    *function =
-        context->Global()->Get(
-            ASCIILiteralToV8String(isolate_, "FindProxyForURL"));
+    *function = context->Global()->Get(
+        ASCIILiteralToV8String(isolate_, "FindProxyForURL"));
     return (*function)->IsFunction();
   }
 
   // Handle an exception thrown by V8.
   void HandleError(v8::Handle<v8::Message> message) {
     base::string16 error_message;
     int line_number = -1;
 
     if (!message.IsEmpty()) {
       line_number = message->GetLineNumber();
@@ skipping 86 matching lines @@
         return;
       }
     }
 
     std::string result;
     bool success;
     bool terminate = false;
 
     {
       v8::Unlocker unlocker(args.GetIsolate());
-      success = context->js_bindings()->ResolveDns(
-          hostname, op, &result, &terminate);
+      success =
+          context->js_bindings()->ResolveDns(hostname, op, &result, &terminate);
     }
 
     if (terminate)
       v8::V8::TerminateExecution(args.GetIsolate());
 
     if (success) {
       args.GetReturnValue().Set(
           ASCIIStringToV8String(args.GetIsolate(), result));
       return;
     }
@@ skipping 68 matching lines @@
   mutable base::Lock lock_;
   ProxyResolverV8* parent_;
   v8::Isolate* isolate_;
   v8::Persistent<v8::External> v8_this_;
   v8::Persistent<v8::Context> v8_context_;
 };
 
 // ProxyResolverV8 ------------------------------------------------------------
 
 ProxyResolverV8::ProxyResolverV8()
-    : ProxyResolver(true /*expects_pac_bytes*/),
-      js_bindings_(NULL) {
+    : ProxyResolver(true /*expects_pac_bytes*/), js_bindings_(NULL) {
 }
 
-ProxyResolverV8::~ProxyResolverV8() {}
+ProxyResolverV8::~ProxyResolverV8() {
+}
 
-int ProxyResolverV8::GetProxyForURL(
-    const GURL& query_url, ProxyInfo* results,
-    const CompletionCallback& /*callback*/,
-    RequestHandle* /*request*/,
-    const BoundNetLog& net_log) {
+int ProxyResolverV8::GetProxyForURL(const GURL& query_url,
+                                    ProxyInfo* results,
+                                    const CompletionCallback& /*callback*/,
+                                    RequestHandle* /*request*/,
+                                    const BoundNetLog& net_log) {
   DCHECK(js_bindings_);
 
   // If the V8 instance has not been initialized (either because
   // SetPacScript() wasn't called yet, or because it failed.
   if (!context_)
     return ERR_FAILED;
 
   // Otherwise call into V8.
   int rv = context_->ResolveProxy(query_url, results);
 
@@ skipping 68 matching lines @@
     return 0;
 
   v8::Locker locked(g_proxy_resolver_isolate_->isolate());
   v8::Isolate::Scope isolate_scope(g_proxy_resolver_isolate_->isolate());
   v8::HeapStatistics heap_statistics;
   g_proxy_resolver_isolate_->isolate()->GetHeapStatistics(&heap_statistics);
   return heap_statistics.used_heap_size();
 }
 
 }  // namespace net